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 _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 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 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)
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_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 __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')
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 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 __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 __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 __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 __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'))
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 check_environment(): msg_not_active = "The Functest environment is not installed." if not os.path.isfile(CONST.__getattribute__('env_active')): raise Exception(msg_not_active) with open(CONST.__getattribute__('env_active'), "r") as env_file: s = env_file.read() if not re.search("1", s): raise Exception(msg_not_active) logger.info("Functest environment is installed.")
def __init__(self, **kwargs): """Initialize testcase.""" if "case_name" not in kwargs: kwargs["case_name"] = "vping_ssh" super(VPingSSH, self).__init__(**kwargs) self.kp_name = CONST.__getattribute__('vping_keypair_name') + self.guid self.kp_priv_file = CONST.__getattribute__('vping_keypair_priv_file') self.kp_pub_file = CONST.__getattribute__('vping_keypair_pub_file') self.sg_name = CONST.__getattribute__('vping_sg_name') + self.guid self.sg_desc = CONST.__getattribute__('vping_sg_desc')
def _create_project(self): """Create project for tests.""" project_creator = deploy_utils.create_project( self.os_creds, ProjectConfig( name=CONST.__getattribute__('tempest_identity_tenant_name') + self.guid, description=CONST.__getattribute__( 'tempest_identity_tenant_description'))) if project_creator is None or project_creator.get_project() is None: raise Exception("Failed to create tenant") self.creators.append(project_creator) return project_creator.get_project().id
def __init__(self, **kwargs): self.logger = logging.getLogger(__name__) super(ClearwaterOnBoardingBase, self).__init__(**kwargs) self.case_dir = pkg_resources.resource_filename( 'functest', 'opnfv_tests/vnf/ims') self.data_dir = CONST.__getattribute__('dir_ims_data') self.result_dir = os.path.join(CONST.__getattribute__('dir_results'), self.case_name) self.test_dir = CONST.__getattribute__('dir_repo_vims_test') if not os.path.exists(self.data_dir): os.makedirs(self.data_dir) if not os.path.exists(self.result_dir): os.makedirs(self.result_dir)
def create_verifier(): logger.info("Create verifier from existing repo...") cmd = ("rally verify delete-verifier --id '{0}' --force").format( CONST.__getattribute__('tempest_verifier_name')) ft_utils.execute_command(cmd, error_msg=( "Verifier %s does not exist." % CONST.__getattribute__('tempest_verifier_name')), verbose=False) cmd = ("rally verify create-verifier --source {0} " "--name {1} --type tempest --system-wide" .format(CONST.__getattribute__('dir_repo_tempest'), CONST.__getattribute__('tempest_verifier_name'))) ft_utils.execute_command_raise(cmd, error_msg='Problem while creating verifier')
def run(self): """ Begins the test execution which should originate from the subclass """ self.logger.info('Begin virtual environment setup') self.start_time = time.time() self.logger.info("vPing Start Time:'%s'" % (datetime.fromtimestamp( self.start_time).strftime('%Y-%m-%d %H:%M:%S'))) image_base_name = '{}-{}'.format( CONST.__getattribute__('vping_image_name'), str(self.guid)) os_image_settings = openstack_tests.cirros_image_settings( image_base_name, image_metadata=self.cirros_image_config) self.logger.info("Creating image with name: '%s'" % image_base_name) self.image_creator = deploy_utils.create_image(self.os_creds, os_image_settings) self.creators.append(self.image_creator) private_net_name = CONST.__getattribute__( 'vping_private_net_name') + self.guid private_subnet_name = CONST.__getattribute__( 'vping_private_subnet_name') + self.guid private_subnet_cidr = CONST.__getattribute__( 'vping_private_subnet_cidr') self.logger.info("Creating network with name: '%s'" % private_net_name) self.network_creator = deploy_utils.create_network( self.os_creds, NetworkSettings(name=private_net_name, subnet_settings=[ SubnetSettings(name=private_subnet_name, cidr=private_subnet_cidr) ])) self.creators.append(self.network_creator) self.logger.info("Creating flavor with name: '%s'" % self.flavor_name) scenario = functest_utils.get_scenario() flavor_metadata = None if 'ovs' in scenario or 'fdio' in scenario: flavor_metadata = create_flavor.MEM_PAGE_SIZE_LARGE flavor_creator = OpenStackFlavor( self.os_creds, FlavorSettings(name=self.flavor_name, ram=512, disk=1, vcpus=1, metadata=flavor_metadata)) flavor_creator.create() self.creators.append(flavor_creator)
def _create_user(self): """Create user for tests.""" user_creator = deploy_utils.create_user( self.os_creds, UserConfig( name=CONST.__getattribute__('tempest_identity_user_name') + self.guid, password=CONST.__getattribute__( 'tempest_identity_user_password'), project_name=CONST.__getattribute__( 'tempest_identity_tenant_name') + self.guid)) if user_creator is None or user_creator.get_user() is None: raise Exception("Failed to create user") self.creators.append(user_creator) return user_creator.get_user().id
def test_create_directories_with_dir(self, mock_logger_debug, mock_logger_info): with mock.patch('functest.ci.prepare_env.os.path.exists', return_value=True): prepare_env.create_directories() mock_logger_info.assert_any_call("Creating needed directories...") mock_logger_debug.assert_any_call(" %s already exists." % CONST.__getattribute__( 'dir_functest_conf')) mock_logger_debug.assert_any_call(" %s already exists." % CONST.__getattribute__( 'dir_functest_data')) mock_logger_debug.assert_any_call(" %s already exists." % CONST.__getattribute__( 'dir_functest_images'))
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): if "case_name" not in kwargs: kwargs["case_name"] = "opera_ims" super(OperaIms, self).__init__(**kwargs) self.logger = logging.getLogger(__name__) self.ellis_file = os.path.join(CONST.__getattribute__('dir_results'), 'ellis.info') self.live_test_file = os.path.join( CONST.__getattribute__('dir_results'), 'live_test_report.json') try: self.openo_msb_endpoint = os.environ['OPENO_MSB_ENDPOINT'] except KeyError: raise Exception('OPENO_MSB_ENDPOINT is not specified,' ' put it as <OPEN-O ip>:<port>') else: self.logger.info('OPEN-O endpoint is: %s', self.openo_msb_endpoint)
def get(self, task_id): # pylint: disable=no-self-use """ GET the log of the task id """ try: uuid.UUID(task_id) except ValueError: return api_utils.result_handler(status=1, data='Invalid task id') task_handler = TasksHandler() try: task = task_handler.get_task_by_taskid(task_id) except ValueError: return api_utils.result_handler(status=1, data='No such task id') task_log_dir = CONST.__getattribute__('dir_results') try: with open(os.path.join(task_log_dir, '{}.log'.format(task_id)), 'r') as log_file: data = log_file.readlines() except OSError as err: if err.errno == errno.ENOENT: return api_utils.result_handler(status=1, data='Log file does not exist') return api_utils.result_handler(status=1, data='Error with log file') return_data = {'data': data} return api_utils.result_handler(status=task.status, data=return_data)
def run_all(self): tiers_to_run = [] msg = prettytable.PrettyTable(header_style='upper', padding_width=5, field_names=[ 'tiers', 'order', 'CI Loop', 'description', 'testcases' ]) for tier in self._tiers.get_tiers(): if (len(tier.get_tests()) != 0 and re.search(CONST.__getattribute__('CI_LOOP'), tier.get_ci_loop()) is not None): tiers_to_run.append(tier) msg.add_row([ tier.get_name(), tier.get_order(), tier.get_ci_loop(), textwrap.fill(tier.description, width=40), textwrap.fill(' '.join( [str(x.get_name()) for x in tier.get_tests()]), width=40) ]) logger.info("TESTS TO BE EXECUTED:\n\n%s\n", msg) for tier in tiers_to_run: self.run_tier(tier)
def test_logger_test_results(self, mock_logger_info): CONST.__setattr__('results_test_db_url', self.db_url) CONST.__setattr__('BUILD_TAG', self.build_tag) CONST.__setattr__('NODE_NAME', self.node_name) CONST.__setattr__('DEPLOY_SCENARIO', self.scenario) with mock.patch('functest.utils.functest_utils.get_version', return_value=self.version): 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 })