def __init__(self, **kwargs): super(SnapsTestRunner, self).__init__(**kwargs) self.logger = logging.getLogger(__name__) self.os_creds = kwargs.get('os_creds') or snaps_utils.get_credentials() 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.netconf_override = None if hasattr(CONST, 'snaps_network_config'): self.netconf_override = CONST.__getattribute__( 'snaps_network_config') self.use_fip = ( CONST.__getattribute__('snaps_use_floating_ips') == 'True') self.use_keystone = ( CONST.__getattribute__('snaps_use_keystone') == 'True') 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')
class OnosBase(testcase.TestCase): onos_repo_path = CONST.__getattribute__('dir_repo_onos') onos_sfc_image_name = CONST.__getattribute__('onos_sfc_image_name') onos_sfc_image_path = os.path.join( CONST.__getattribute__('dir_functest_images'), CONST.__getattribute__('onos_sfc_image_file_name')) onos_sfc_path = pkg_resources.resource_filename( 'functest', 'opnfv_tests/sdn/onos/sfc') installer_type = CONST.__getattribute__('INSTALLER_TYPE') logger = logging.getLogger(__name__) def __init__(self, **kwargs): if "case_name" not in kwargs: kwargs["case_name"] = "onos_base" super(OnosBase, self).__init__(**kwargs) def run(self): self.start_time = time.time() try: self._run() res = testcase.TestCase.EX_OK except Exception as e: self.logger.error('Error with run: %s', e) res = testcase.TestCase.EX_RUN_ERROR self.stop_time = time.time() return res def _run(self): raise NotImplementedError('_run is not implemented')
def test_logger_test_results(self, mock_logger_info): CONST.__setattr__('results_test_db_url', self.db_url) with mock.patch('functest.utils.functest_utils.get_pod_name', return_value=self.node_name), \ mock.patch('functest.utils.functest_utils.get_scenario', return_value=self.scenario), \ mock.patch('functest.utils.functest_utils.get_version', return_value=self.version), \ mock.patch('functest.utils.functest_utils.get_build_tag', return_value=self.build_tag): functest_utils.logger_test_results(self.project, self.case_name, self.status, self.details) mock_logger_info.assert_called_once_with( "\n" "****************************************\n" "\t %(p)s/%(n)s results \n\n" "****************************************\n" "DB:\t%(db)s\n" "pod:\t%(pod)s\n" "version:\t%(v)s\n" "scenario:\t%(s)s\n" "status:\t%(c)s\n" "build tag:\t%(b)s\n" "details:\t%(d)s\n" % { 'p': self.project, 'n': self.case_name, 'db': CONST.__getattribute__('results_test_db_url'), 'pod': self.node_name, 'v': self.version, 's': self.scenario, 'c': self.status, 'b': self.build_tag, 'd': self.details })
def _run(self, args): # pylint: disable=no-self-use """ The built_in function to run a test case """ case_name = args.get('testcase') self._update_logging_ini(args.get('task_id')) if not os.path.isfile(CONST.__getattribute__('env_active')): raise Exception("Functest environment is not ready.") else: try: cmd = "run_tests -t {}".format(case_name) runner = ft_utils.execute_command(cmd) except Exception: # pylint: disable=broad-except result = 'FAIL' LOGGER.exception("Running test case %s failed!", case_name) if runner == os.EX_OK: result = 'PASS' else: result = 'FAIL' env_info = { 'installer': CONST.__getattribute__('INSTALLER_TYPE'), 'scenario': CONST.__getattribute__('DEPLOY_SCENARIO'), 'build_tag': CONST.__getattribute__('BUILD_TAG'), 'ci_loop': CONST.__getattribute__('CI_LOOP') } result = { 'task_id': args.get('task_id'), 'case_name': case_name, 'env_info': env_info, 'result': result } return {'result': result}
def __init__(self, project='functest', case_name='', repo='', cmd=''): super(VnfOnBoardingBase, self).__init__(case_name=case_name) self.repo = repo self.project_name = project self.cmd = cmd self.details = {} self.result_dir = CONST.dir_results self.details['orchestrator'] = {} self.details['vnf'] = {} self.details['test_vnf'] = {} self.images = {} try: self.tenant_name = CONST.__getattribute__( 'vnf_{}_tenant_name'.format(self.case_name)) self.tenant_description = CONST.__getattribute__( 'vnf_{}_tenant_description'.format(self.case_name)) except Exception: # raise Exception("Unknown VNF case=" + self.case_name) self.logger.error("Unknown VNF case={}".format(self.case_name)) try: self.images = CONST.__getattribute__('vnf_{}_tenant_images'.format( self.case_name)) except Exception: self.logger.warn("No tenant image defined for this VNF")
def test_source_rc_missing_installer_ip(self): with mock.patch('functest.ci.prepare_env.os.path.isfile', return_value=False), \ self.assertRaises(Exception): CONST.__setattr__('INSTALLER_IP', None) CONST.__setattr__('openstack_creds', 'test_creds') prepare_env.source_rc_file()
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 create_rally_deployment(): # set the architecture to default pod_arch = os.getenv("POD_ARCH", None) arch_filter = ['aarch64'] if pod_arch and pod_arch in arch_filter: logger.info("Apply aarch64 specific to rally config...") with open(RALLY_AARCH64_PATCH_PATH, "r") as f: rally_patch_conf = f.read() for line in fileinput.input(RALLY_CONF_PATH, inplace=1): print line, if "cirros|testvm" in line: print rally_patch_conf logger.info("Creating Rally environment...") cmd = "rally deployment destroy opnfv-rally" ft_utils.execute_command(cmd, error_msg=( "Deployment %s does not exist." % CONST.__getattribute__('rally_deployment_name')), verbose=False) cmd = ("rally deployment create --fromenv --name={0}" .format(CONST.__getattribute__('rally_deployment_name'))) error_msg = "Problem while creating Rally deployment" ft_utils.execute_command_raise(cmd, error_msg=error_msg) cmd = "rally deployment check" error_msg = "OpenStack not responding or faulty Rally deployment." ft_utils.execute_command_raise(cmd, error_msg=error_msg)
def apply_tempest_blacklist(self): logger.debug("Applying tempest blacklist...") cases_file = self.read_file(conf_utils.TEMPEST_RAW_LIST) result_file = open(conf_utils.TEMPEST_LIST, 'w') black_tests = [] try: installer_type = CONST.__getattribute__('INSTALLER_TYPE') deploy_scenario = CONST.__getattribute__('DEPLOY_SCENARIO') if (bool(installer_type) * bool(deploy_scenario)): # if INSTALLER_TYPE and DEPLOY_SCENARIO are set we read the # file black_list_file = open(conf_utils.TEMPEST_BLACKLIST) black_list_yaml = yaml.safe_load(black_list_file) black_list_file.close() for item in black_list_yaml: scenarios = item['scenarios'] installers = item['installers'] if (deploy_scenario in scenarios and installer_type in installers): tests = item['tests'] for test in tests: black_tests.append(test) break except Exception: black_tests = [] logger.debug("Tempest blacklist file does not exist.") for cases_line in cases_file: for black_tests_line in black_tests: if black_tests_line in cases_line: break else: result_file.write(str(cases_line) + '\n') result_file.close()
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: self.os_creds = openstack_tests.get_credentials( os_env_file=CONST.__getattribute__('openstack_creds'), proxy_settings_str=None, ssh_proxy_cmd=None) 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 = functest_utils.get_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 test_create_tempest_resources_missing_image(self): with mock.patch('functest.opnfv_tests.openstack.tempest.conf_utils.' 'os_utils.get_keystone_client', return_value=mock.Mock()), \ mock.patch('functest.opnfv_tests.openstack.tempest.conf_utils.' 'os_utils.create_tenant', return_value='test_tenant_id'), \ mock.patch('functest.opnfv_tests.openstack.tempest.conf_utils.' 'os_utils.create_user', return_value='test_user_id'), \ mock.patch('functest.opnfv_tests.openstack.tempest.conf_utils.' 'os_utils.create_shared_network_full', return_value=mock.Mock()), \ mock.patch('functest.opnfv_tests.openstack.tempest.conf_utils.' 'os_utils.get_or_create_image', return_value=(mock.Mock(), None)), \ self.assertRaises(Exception) as context: CONST.__setattr__('tempest_use_custom_images', True) conf_utils.create_tempest_resources() msg = 'Failed to create image' self.assertTrue(msg in context) CONST.__setattr__('tempest_use_custom_images', False) conf_utils.create_tempest_resources(use_custom_images=True) msg = 'Failed to create image' self.assertTrue(msg in context)
def __init__(self): self.username = "" self.password = "" self.auth_url = "" self.tenant_name = "" self.region_name = "" data_dir = data_dir = CONST.__getattribute__('dir_router_data') self.vnf_data_dir = data_dir self.opnfv_vnf_data_dir = "opnfv-vnf-data/" self.command_template_dir = "command_template/" self.test_scenario_yaml = "test_scenario.yaml" test_env_config_yaml_file = "test_env_config.yaml" self.test_cmd_map_yaml_file = "test_cmd_map.yaml" self.test_env_config_yaml = os.path.join(self.vnf_data_dir, self.opnfv_vnf_data_dir, test_env_config_yaml_file) self.blueprint_dir = "opnfv-vnf-vyos-blueprint/" self.blueprint_file_name = "function-test-openstack-blueprint.yaml" if not os.path.exists(self.vnf_data_dir): os.makedirs(self.vnf_data_dir) case_dir = pkg_resources.resource_filename('functest', 'opnfv_tests/vnf/router') config_file_name = CONST.__getattribute__( 'vnf_{}_config'.format("vyos_vrouter")) config_file = os.path.join(case_dir, config_file_name) with open(config_file) as file_fd: vrouter_config_yaml = yaml.safe_load(file_fd) file_fd.close() test_data = vrouter_config_yaml.get("test_data") self.logger.debug("Downloading the test data.") vrouter_data_path = self.vnf_data_dir + self.opnfv_vnf_data_dir if not os.path.exists(vrouter_data_path): Repo.clone_from(test_data['url'], vrouter_data_path, branch=test_data['branch']) with open(self.test_env_config_yaml) as file_fd: test_env_config_yaml = yaml.safe_load(file_fd) file_fd.close() self.image = test_env_config_yaml.get("general").get("images").get( "vyos") self.tester_image = test_env_config_yaml.get("general").get( "images").get("tester_vm_os") self.test_result_json_file = "test_result.json" if os.path.isfile(self.test_result_json_file): os.remove(self.test_result_json_file) self.logger.debug("removed %s" % self.test_result_json_file)
def run_defcore_default(self): """Run default defcore sys command.""" options = ["-v"] if not self.insecure else ["-v", self.insecure] cmd = (["refstack-client", "test", "-c", self.confpath] + options + ["--test-list", self.defcorelist]) LOGGER.info("Starting Refstack_defcore test case: '%s'.", cmd) with open( os.path.join(conf_utils.REFSTACK_RESULTS_DIR, "environment.log"), 'w+') as f_env: f_env.write( ("Refstack environment:\n" " SUT: {}\n Scenario: {}\n Node: {}\n Date: {}\n").format( CONST.__getattribute__('INSTALLER_TYPE'), CONST.__getattribute__('DEPLOY_SCENARIO'), CONST.__getattribute__('NODE_NAME'), time.strftime("%a %b %d %H:%M:%S %Z %Y"))) with open( os.path.join(conf_utils.REFSTACK_RESULTS_DIR, "refstack.log"), 'w+') as f_stdout: subprocess.call(cmd, shell=False, stdout=f_stdout, stderr=subprocess.STDOUT)
def test_load_config_ex(self, loader_mock=None, get_mock=None): """Test load config with exception.""" CONST.__setattr__('NODE_NAME', 'MOCK_POD') with self.assertRaises(AssertionError): EnergyRecorder.energy_recorder_api = None EnergyRecorder.load_config() self.assertEquals(EnergyRecorder.energy_recorder_api, None)
def test_install_rally(self, mock_exec, mock_exec_raise, mock_logger_info, mock_os_utils): mock_os_utils.return_value = self._get_rally_creds() prepare_env.install_rally() cmd = "rally deployment destroy opnfv-rally" error_msg = "Deployment %s does not exist." % \ CONST.__getattribute__('rally_deployment_name') mock_logger_info.assert_any_call("Creating Rally environment...") mock_exec.assert_any_call(cmd, error_msg=error_msg, verbose=False) cmd = "rally deployment create --file=rally_conf.json --name=" cmd += CONST.__getattribute__('rally_deployment_name') error_msg = "Problem while creating Rally deployment" mock_exec_raise.assert_any_call(cmd, error_msg=error_msg) cmd = "rally deployment check" error_msg = ("OpenStack not responding or " "faulty Rally deployment.") mock_exec_raise.assert_any_call(cmd, error_msg=error_msg) cmd = "rally deployment list" error_msg = ("Problem while listing " "Rally deployment.") mock_exec.assert_any_call(cmd, error_msg=error_msg) cmd = "rally plugin list | head -5" error_msg = ("Problem while showing " "Rally plugins.") mock_exec.assert_any_call(cmd, error_msg=error_msg)
def test_load_config_api_ko(self, loader_mock=None, get_mock=None): """Test load config with API unavailable.""" CONST.__setattr__('NODE_NAME', 'MOCK_POD') EnergyRecorder.energy_recorder_api = None EnergyRecorder.load_config() self.assertEquals(EnergyRecorder.energy_recorder_api["available"], False)
def logger_test_results(project, case_name, status, details): """ Format test case results for the logger """ pod_name = CONST.__getattribute__('NODE_NAME') scenario = CONST.__getattribute__('DEPLOY_SCENARIO') version = get_version() build_tag = CONST.__getattribute__('BUILD_TAG') db_url = CONST.__getattribute__("results_test_db_url") logger.info( "\n" "****************************************\n" "\t %(p)s/%(n)s results \n\n" "****************************************\n" "DB:\t%(db)s\n" "pod:\t%(pod)s\n" "version:\t%(v)s\n" "scenario:\t%(s)s\n" "status:\t%(c)s\n" "build tag:\t%(b)s\n" "details:\t%(d)s\n" % { 'p': project, 'n': case_name, 'db': db_url, 'pod': pod_name, 'v': version, 's': scenario, 'c': status, 'b': build_tag, 'd': details })
def test_run_all_default(self, mock_logger_info): with mock.patch( 'functest.ci.run_tests.Runner.run_tier') as mock_method: CONST.__setattr__('CI_LOOP', 'test_ci_loop') self.runner.run_all(self.tiers) mock_method.assert_any_call(self.tier) self.assertTrue(mock_logger_info.called)
def __init__(self, **kwargs): if "case_name" not in kwargs: kwargs["case_name"] = "orchestra_clearwaterims" super(ClearwaterImsVnf, self).__init__(**kwargs) self.logger = logging.getLogger("functest.ci.run_tests.orchestra") self.logger.info("kwargs %s", (kwargs)) self.case_dir = pkg_resources.resource_filename( 'functest', 'opnfv_tests/vnf/ims/') self.data_dir = CONST.__getattribute__('dir_ims_data') self.test_dir = CONST.__getattribute__('dir_repo_vims_test') self.created_resources = [] self.logger.info("%s VNF onboarding test starting", self.case_name) try: self.config = CONST.__getattribute__( 'vnf_{}_config'.format(self.case_name)) except BaseException: raise Exception("Orchestra VNF config file not found") config_file = self.case_dir + self.config self.mano = dict( get_config("mano", config_file), details={} ) self.logger.debug("Orchestrator configuration %s", self.mano) self.details['orchestrator'] = dict( name=self.mano['name'], version=self.mano['version'], status='ERROR', result='' ) self.vnf = dict( get_config(self.case_name, config_file), ) self.logger.debug("VNF configuration: %s", self.vnf) self.details['vnf'] = dict( name=self.vnf['name'], ) self.details['test_vnf'] = dict( name=self.case_name, ) # Orchestra base Data directory creation if not os.path.exists(self.data_dir): os.makedirs(self.data_dir) self.images = get_config("tenant_images.orchestrator", config_file) self.images.update( get_config( "tenant_images.%s" % self.case_name, config_file)) self.snaps_creds = None
def __init__(self): self.os_auth_url = CONST.__getattribute__('OS_AUTH_URL') self.endpoint_ip = None self.endpoint_port = None self.openstack_creds = CONST.__getattribute__('openstack_creds') if self.os_auth_url: self.endpoint_ip = urlparse(self.os_auth_url).hostname self.endpoint_port = urlparse(self.os_auth_url).port
def test_check_env_variables_with_node(self, mock_logger_warn, mock_logger_info): CONST.__setattr__('NODE_NAME', mock.Mock()) prepare_env.check_env_variables() mock_logger_info.assert_any_call("Checking environment variables" "...") mock_logger_info.assert_any_call(test_utils. SubstrMatch(" NODE_NAME="))
def test_check_env_variables_missing_inst_type(self, mock_logger_warn, mock_logger_info): CONST.__setattr__('INSTALLER_TYPE', None) prepare_env.check_env_variables() mock_logger_info.assert_any_call("Checking environment variables" "...") mock_logger_warn.assert_any_call("The env variable 'INSTALLER_TYPE'" " is not defined.")
def test_check_env_variables_with_inst_ip(self, mock_logger_warn, mock_logger_info): CONST.__setattr__('INSTALLER_IP', mock.Mock()) prepare_env.check_env_variables() mock_logger_info.assert_any_call("Checking environment variables" "...") mock_logger_info.assert_any_call(test_utils. SubstrMatch(" INSTALLER_IP="))
def test_check_env_variables_with_scenario(self, mock_logger_warn, mock_logger_info): CONST.__setattr__('DEPLOY_SCENARIO', 'test_scenario') prepare_env.check_env_variables() mock_logger_info.assert_any_call("Checking environment variables" "...") mock_logger_info.assert_any_call(test_utils. SubstrMatch("DEPLOY_SCENARIO="))
def test_check_env_variables_with_ci_debug(self, mock_logger_warn, mock_logger_info): CONST.__setattr__('CI_DEBUG', mock.Mock()) prepare_env.check_env_variables() mock_logger_info.assert_any_call("Checking environment variables" "...") mock_logger_info.assert_any_call(test_utils. SubstrMatch(" CI_DEBUG="))
def test_wrong_shema(self): CONST.__setattr__('results_test_db_url', '/dev/null') self.assertFalse( functest_utils.push_results_to_db(self._project_name, self._case_name, self._start_time, self._stop_time, self._result, {}))
def setUp(self): self.default_args = {'config': self._config, 'testlist': self._testlist} CONST.__setattr__('OS_AUTH_URL', 'https://ip:5000/v3') CONST.__setattr__('OS_INSECURE', 'true') self.os_creds = OSCreds( username='******', password='******', auth_url='http://foo.com:5000/v3', project_name='bar')
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 __init__(self): self.os_auth_url = CONST.__getattribute__('OS_AUTH_URL') self.endpoint_ip = None self.endpoint_port = None self.openstack_creds = CONST.__getattribute__('openstack_creds') self.snapshot_file = CONST.__getattribute__('openstack_snapshot_file') if self.os_auth_url: self.endpoint_ip = self.os_auth_url.rsplit("/")[2].rsplit(":")[0] self.endpoint_port = self.os_auth_url.rsplit("/")[2].rsplit(":")[1]
def __init__(self): self.executed_test_cases = {} self.overall_result = Result.EX_OK self.clean_flag = True self.report_flag = False self._tiers = tb.TierBuilder( CONST.__getattribute__('INSTALLER_TYPE'), CONST.__getattribute__('DEPLOY_SCENARIO'), pkg_resources.resource_filename('functest', 'ci/testcases.yaml'))