def get_testcase_list(logger=None, **kwargs): dt_testcase.Testcase.load() testcase_list = kwargs['testcase'] # If specify 'testcase' on the CLI, ignore 'testsuite' and 'testarea'. In # this case, all test cases are marked as mandatory=false in the result # file because there is no testsuite to relate to. # If 'testcase' is not specified on the CLI, check the combination of # 'testsuite' and 'testarea' if testcase_list: return check_testcase_list(testcase_list, logger) testsuite_validation = False testsuite = kwargs['testsuite'] if testsuite in dt_cfg.dovetail_config['testsuite_supported']: testsuite_validation = True origin_testarea = kwargs['testarea'] testarea_validation, testarea = dt_testcase.Testcase.check_testarea( origin_testarea) if testsuite_validation and testarea_validation: testsuite_yaml = load_testsuite(testsuite) dt_cfg.dovetail_config['version'] = dt_utils.get_value_from_dict( 'version', testsuite_yaml) dt_cfg.dovetail_config['vnf_type'] = dt_utils.get_value_from_dict( 'vnf_type', testsuite_yaml) testcase_list = dt_testcase.Testcase.get_testcases_for_testsuite( testsuite_yaml, testarea) return check_testcase_list(testcase_list, logger) elif not testsuite_validation: logger.error('Test suite {} is not defined.'.format(testsuite)) else: logger.error('Test area {} is not defined.'.format(origin_testarea)) return None
def _get_config(cls, field, project_cfg, testcase_cfg): value = dt_utils.get_value_from_dict(field, testcase_cfg) if not value: value = dt_utils.get_value_from_dict(field, project_cfg) if not value: cls.logger.error("Couldn't find key {}.".format(field)) return None return value
def check_tc_result(self, testcase): result_path = dt_cfg.dovetail_config['result_dir'] check_results_files = dt_utils.get_value_from_dict( 'report.check_results_files', testcase.testcase) if not check_results_files: self.logger.error("Failed to get 'check_results_files' from config" " file of test case {}".format(testcase.name())) self.check_result(testcase) return None result_files = [] for check_results_file in check_results_files: result_file = os.path.join(result_path, check_results_file) if not os.path.isfile(result_file): self.logger.error( 'Failed to store results with file {}.'.format( result_file)) self.check_result(testcase) return None else: result_files.append(result_file) self.logger.info( 'Results have been stored with files: {}.'.format(result_files)) result = self.get_result(testcase, result_files) self.check_result(testcase, result) return result
def get_testcases_for_testsuite(cls, testsuite, testarea): testcase_list = [] selected_tests = [] testcases = dt_utils.get_value_from_dict('testcases_list', testsuite) mandatory = dt_utils.get_value_from_dict('mandatory', testcases) optional = dt_utils.get_value_from_dict('optional', testcases) if not testcases: return testcase_list if dt_cfg.dovetail_config['mandatory']: if not mandatory: cls.logger.error("There is no mandatory test case in " "test suite {}".format(testsuite['name'])) else: selected_tests += mandatory if dt_cfg.dovetail_config['optional']: if not optional: cls.logger.error("There is no optional test case in " "test suite {}".format(testsuite['name'])) else: selected_tests += optional if (not dt_cfg.dovetail_config['mandatory'] and not dt_cfg.dovetail_config['optional']): if mandatory: selected_tests += mandatory if optional: selected_tests += optional if not selected_tests: return None for value in selected_tests: for area in testarea: if cls.check_testcase_area(value, area): testcase_list.append(value) if mandatory and value in mandatory: Testcase.testcase_list[value].is_mandatory = True else: Testcase.testcase_list[value].is_mandatory = False break return testcase_list
def archive_logs(self): result_path = os.path.join(os.environ['DOVETAIL_HOME'], 'results') src_files = dt_utils.get_value_from_dict('report.source_archive_files', self.testcase.testcase) dest_files = dt_utils.get_value_from_dict('report.dest_archive_files', self.testcase.testcase) if not src_files and not dest_files: return True if not (src_files and dest_files) or len(src_files) != len(dest_files): self.logger.error( "Can't find corresponding 'result_dest_files' " "for 'result_source_files' with testcase {}".format( self.testcase.name())) return False res = True for index in range(0, len(src_files)): src_file_path = os.path.join(result_path, src_files[index]) dest_file_path = os.path.join(result_path, dest_files[index]) if os.path.isfile(src_file_path): os.renames(src_file_path, dest_file_path) else: self.logger.error("Can't find file {}.".format(src_file_path)) res = False return res
def create(self, docker_image): dovetail_config = dt_cfg.dovetail_config project_cfg = dovetail_config[self.valid_type] kwargs = dt_utils.get_value_from_dict('opts', project_cfg) shell = dt_utils.get_value_from_dict('shell', project_cfg) if not shell: return None env_list = dt_utils.get_value_from_dict('envs', project_cfg) if env_list: kwargs['environment'] = \ [env for env in env_list if env is not None] volume_list = dt_utils.get_value_from_dict('volumes', project_cfg) kwargs['volumes'] = [vol for vol in volume_list if vol is not None] kwargs['extra_hosts'] = dt_utils.get_hosts_info(self.logger) try: self.container = self.client.containers.run( docker_image, shell, **kwargs) except (docker.errors.ContainerError, docker.errors.ImageNotFound, docker.errors.APIError): return None return self.container.id
def exec_cmd(self, sub_cmd, exit_on_error=False): if not sub_cmd: return (1, 'sub_cmd is empty') shell = dt_utils.get_value_from_dict( 'shell', dt_cfg.dovetail_config[self.valid_type]) if not shell: return (1, 'shell is empty') cmd = '{} -c "{}"'.format(shell, sub_cmd) try: result = self.container.exec_run(cmd) except docker.errors.APIError as e: result = (e.response.status_code, str(e)) self.logger.error(e) if exit_on_error: sys.exit(1) return result
def clean(self): try: self.container.remove(force=True) self.logger.debug( 'container: {} was removed'.format(self.container.name)) except docker.errors.APIError as e: self.logger.error(e) extra_containers = dt_utils.get_value_from_dict( 'extra_container', dt_cfg.dovetail_config[self.valid_type]) if extra_containers: for container_name in extra_containers: container = self.get_container(container_name) if container: try: container.remove(force=True) self.logger.debug( 'container: {} was removed'.format(container_name)) except docker.errors.APIError as e: self.logger.error(e)
def check_tc_result(cls, testcase): result_path = dt_cfg.dovetail_config['result_dir'] check_results_file = dt_utils.get_value_from_dict( 'report.check_results_file', testcase.testcase) if not check_results_file: cls.logger.error("Failed to get 'check_results_file' from config " "file of test case {}".format(testcase.name())) cls.check_result(testcase) return None result_file = os.path.join(result_path, check_results_file) if os.path.isfile(result_file): cls.logger.info( "Results have been stored with file {}.".format(result_file)) result = cls.get_result(testcase, result_file) cls.check_result(testcase, result) return result else: cls.logger.error( "Failed to store results with file {}.".format(result_file)) cls.check_result(testcase) return None
def crawl_from_file(self, testcase, file_path): if not os.path.exists(file_path): self.logger.error('Result file not found: {}'.format(file_path)) return None criteria = 'FAIL' with open(file_path, 'r') as f: for jsonfile in f: data = json.loads(jsonfile) try: criteria = dt_utils.get_value_from_dict( "result.criteria", data) if criteria == 'PASS': valid_tc = testcase.validate_testcase() details = data['result']['testcases'][valid_tc] sla_pass = details['tc_data'][0]['data']['sla_pass'] if not 1 == sla_pass: criteria = 'FAIL' except KeyError as e: self.logger.exception('Pass flag not found {}'.format(e)) json_results = {'criteria': criteria} testcase.set_results(json_results) return json_results
def sub_testcase(self): return dt_utils.get_value_from_dict('report.sub_testcase_list', self.testcase)
def create(cls, valid_type, testcase_name, docker_image): dovetail_config = dt_cfg.dovetail_config project_cfg = dovetail_config[valid_type] # credentials file openrc.sh is neccessary openrc = cls.openrc_volume(valid_type) if not openrc: return None opts = dt_utils.get_value_from_dict('opts', project_cfg) envs = dt_utils.get_value_from_dict('envs', project_cfg) volumes = dt_utils.get_value_from_dict('volumes', project_cfg) opts = ' ' if not opts else opts envs = ' ' if not envs else envs volumes = ' ' if not volumes else ' '.join(volumes) # CI_DEBUG is used for showing the debug logs of the upstream projects # BUILD_TAG is the unique id for this test DEBUG = os.getenv('DEBUG') if DEBUG is not None and DEBUG.lower() == "true": envs = envs + ' -e CI_DEBUG=true' else: envs = envs + ' -e CI_DEBUG=false' envs = envs + ' -e BUILD_TAG=%s-%s' % (dovetail_config['build_tag'], testcase_name) hosts_config = dt_utils.get_hosts_info(cls.logger) # This part will be totally removed after remove the 4 functions # set_functest_config has been removed # set_yardstick_config has been removed # set_bottlenecks_config has been removed # set_vnftest_config config = " " if valid_type.lower() == "vnftest": config = cls.set_vnftest_config() if not config: return None # for refstack, support user self_defined configuration config_volume = \ ' -v %s:%s ' % (os.getenv("DOVETAIL_HOME"), project_cfg['config']['dir']) cacert_volume = "" https_enabled = dt_utils.check_https_enabled(cls.logger) cacert = os.getenv('OS_CACERT') insecure = os.getenv('OS_INSECURE') if cacert is not None: if dt_utils.check_cacert_file(cacert, cls.logger): cacert_volume = ' -v %s:%s ' % (cacert, cacert) else: return None elif https_enabled: if insecure and insecure.lower() == 'true': cls.logger.debug("Use the insecure mode...") else: cls.logger.error("https enabled, please set OS_CACERT or " "insecure mode...") return None images_volume = '' if project_cfg['config'].get('images', None): images_volume = '-v {}:{}'.format(dovetail_config['images_dir'], project_cfg['config']['images']) result_volume = ' -v %s:%s ' % (dovetail_config['result_dir'], project_cfg['result']['dir']) cmd = 'sudo docker run {opts} {envs} {volumes} {config} ' \ '{hosts_config} {openrc} {cacert_volume} {config_volume} ' \ '{result_volume} {images_volume} {docker_image} /bin/bash' \ .format(**locals()) dt_utils.exec_cmd(cmd, cls.logger) ret, container_id = \ dt_utils.exec_cmd("sudo docker ps | grep " + docker_image + " | awk '{print $1}' | head -1", cls.logger) cls.container_list[valid_type] = container_id if valid_type.lower() == 'vnftest': cls.set_vnftest_conf_file(container_id) return container_id