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')
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_logger_test_results(self, mock_logger_info):
CONST.__setattr__('results_test_db_url', self.db_url)
with mock.patch('functest.utils.functest_utils.get_pod_name',
return_value=self.node_name), \
mock.patch('functest.utils.functest_utils.get_scenario',
return_value=self.scenario), \
mock.patch('functest.utils.functest_utils.get_version',
return_value=self.version), \
mock.patch('functest.utils.functest_utils.get_build_tag',
return_value=self.build_tag):
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
})
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 __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 test_source_rc_missing_installer_ip(self):
with mock.patch('functest.ci.prepare_env.os.path.isfile',
return_value=False), \
self.assertRaises(Exception):
CONST.__setattr__('INSTALLER_IP', None)
CONST.__setattr__('openstack_creds', 'test_creds')
prepare_env.source_rc_file()
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 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)
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 test_create_tempest_resources_missing_image(self):
with mock.patch('functest.opnfv_tests.openstack.tempest.conf_utils.'
'os_utils.get_keystone_client',
return_value=mock.Mock()), \
mock.patch('functest.opnfv_tests.openstack.tempest.conf_utils.'
'os_utils.create_tenant',
return_value='test_tenant_id'), \
mock.patch('functest.opnfv_tests.openstack.tempest.conf_utils.'
'os_utils.create_user',
return_value='test_user_id'), \
mock.patch('functest.opnfv_tests.openstack.tempest.conf_utils.'
'os_utils.create_shared_network_full',
return_value=mock.Mock()), \
mock.patch('functest.opnfv_tests.openstack.tempest.conf_utils.'
'os_utils.get_or_create_image',
return_value=(mock.Mock(), None)), \
self.assertRaises(Exception) as context:
CONST.__setattr__('tempest_use_custom_images', True)
conf_utils.create_tempest_resources()
msg = 'Failed to create image'
self.assertTrue(msg in context)
CONST.__setattr__('tempest_use_custom_images', False)
conf_utils.create_tempest_resources(use_custom_images=True)
msg = 'Failed to create image'
self.assertTrue(msg in context)
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 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 test_load_config_ex(self, loader_mock=None, get_mock=None):
"""Test load config with exception."""
CONST.__setattr__('NODE_NAME', 'MOCK_POD')
with self.assertRaises(AssertionError):
EnergyRecorder.energy_recorder_api = None
EnergyRecorder.load_config()
self.assertEquals(EnergyRecorder.energy_recorder_api, None)
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 test_load_config_api_ko(self, loader_mock=None, get_mock=None):
"""Test load config with API unavailable."""
CONST.__setattr__('NODE_NAME', 'MOCK_POD')
EnergyRecorder.energy_recorder_api = None
EnergyRecorder.load_config()
self.assertEquals(EnergyRecorder.energy_recorder_api["available"],
False)
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 test_run_all_default(self, mock_logger_info):
with mock.patch(
'functest.ci.run_tests.Runner.run_tier') as mock_method:
CONST.__setattr__('CI_LOOP', 'test_ci_loop')
self.runner.run_all(self.tiers)
mock_method.assert_any_call(self.tier)
self.assertTrue(mock_logger_info.called)
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 test_check_env_variables_with_node(self, mock_logger_warn,
mock_logger_info):
CONST.__setattr__('NODE_NAME', mock.Mock())
prepare_env.check_env_variables()
mock_logger_info.assert_any_call("Checking environment variables"
"...")
mock_logger_info.assert_any_call(test_utils.
SubstrMatch(" NODE_NAME="))
def test_check_env_variables_missing_inst_type(self, mock_logger_warn,
mock_logger_info):
CONST.__setattr__('INSTALLER_TYPE', None)
prepare_env.check_env_variables()
mock_logger_info.assert_any_call("Checking environment variables"
"...")
mock_logger_warn.assert_any_call("The env variable 'INSTALLER_TYPE'"
" is not defined.")
def test_check_env_variables_with_inst_ip(self, mock_logger_warn,
mock_logger_info):
CONST.__setattr__('INSTALLER_IP', mock.Mock())
prepare_env.check_env_variables()
mock_logger_info.assert_any_call("Checking environment variables"
"...")
mock_logger_info.assert_any_call(test_utils.
SubstrMatch(" INSTALLER_IP="))
def test_check_env_variables_with_scenario(self, mock_logger_warn,
mock_logger_info):
CONST.__setattr__('DEPLOY_SCENARIO', 'test_scenario')
prepare_env.check_env_variables()
mock_logger_info.assert_any_call("Checking environment variables"
"...")
mock_logger_info.assert_any_call(test_utils.
SubstrMatch("DEPLOY_SCENARIO="))
def test_check_env_variables_with_ci_debug(self, mock_logger_warn,
mock_logger_info):
CONST.__setattr__('CI_DEBUG', mock.Mock())
prepare_env.check_env_variables()
mock_logger_info.assert_any_call("Checking environment variables"
"...")
mock_logger_info.assert_any_call(test_utils.
SubstrMatch(" CI_DEBUG="))
def test_wrong_shema(self):
CONST.__setattr__('results_test_db_url', '/dev/null')
self.assertFalse(
functest_utils.push_results_to_db(self._project_name,
self._case_name,
self._start_time,
self._stop_time, self._result,
{}))
def setUp(self):
self.default_args = {'config': self._config,
'testlist': self._testlist}
CONST.__setattr__('OS_AUTH_URL', 'https://ip:5000/v3')
CONST.__setattr__('OS_INSECURE', 'true')
self.os_creds = OSCreds(
username='******', password='******',
auth_url='http://foo.com:5000/v3', project_name='bar')
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 __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'))
