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