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, "Lacking of key word 'shell' in config file."
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['mounts'], msg = dt_utils.get_mount_list(project_cfg)
if not kwargs['mounts']:
return None, msg
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) as e:
return None, e
return self.container.id, 'Successfully to create container.'
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(self, 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:
self.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 list_one_testsuite(testsuite):
testsuite_stream = Testsuite.get(testsuite)
if testsuite_stream:
mandatory = dt_utils.get_value_from_dict(
'testcases_list.mandatory', testsuite_stream)
optional = dt_utils.get_value_from_dict(
'testcases_list.optional', testsuite_stream)
if mandatory:
click.echo("- mandatory")
for testcase in mandatory:
click.echo(" {}".format(testcase))
if optional:
click.echo("- optional")
for testcase in optional:
click.echo(" {}".format(testcase))
if not (mandatory or optional):
click.echo("No testcase in testsuite {}".format(testsuite))
else:
click.echo("testsuite {} does not exist".format(testsuite))
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 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 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 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 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)
