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
})
