class DominoCases(testcase_base.TestcaseBase):
DOMINO_REPO = ft_constants.DOMINO_REPO_DIR
RESULTS_DIR = ft_constants.FUNCTEST_RESULTS_DIR
logger = ft_logger.Logger("domino").getLogger()
def __init__(self):
super(DominoCases, self).__init__()
self.project_name = "domino"
self.case_name = "domino-multinode"
def main(self, **kwargs):
cmd = 'cd %s && ./tests/run_multinode.sh' % self.DOMINO_REPO
log_file = os.path.join(self.RESULTS_DIR, "domino.log")
start_time = time.time()
ret = ft_utils.execute_command(cmd,
output_file=log_file)
stop_time = time.time()
if ret == 0:
self.logger.info("domino OK")
status = 'PASS'
else:
self.logger.info("domino FAILED")
status = "FAIL"
# report status only if tests run (FAIL OR PASS)
self.criteria = status
self.start_time = start_time
self.stop_time = stop_time
self.details = {}
def run(self):
kwargs = {}
return self.main(**kwargs)
def __init__(self):
super(Parser, self).__init__()
self.project_name = "parser"
self.case_name = "parser-basics"
self.logger = ft_logger.Logger("parser").getLogger()
self.log_file = os.path.join(ft_constants.FUNCTEST_RESULTS_DIR,
"parser.log")
def setUp(self):
with mock.patch('__builtin__.open', mock.mock_open()):
with mock.patch('functest.utils.functest_logger.os.path.exists',
return_value=True), \
mock.patch('functest.utils.functest_logger.'
'json.load'), \
mock.patch('functest.utils.functest_logger.'
'logging.config.dictConfig') as m:
self.logger = functest_logger.Logger('os_utils')
self.assertTrue(m.called)
with mock.patch('functest.utils.functest_logger.os.path.exists',
return_value=False), \
mock.patch('functest.utils.functest_logger.'
'logging.basicConfig') as m:
self.logger = functest_logger.Logger('os_utils')
self.assertTrue(m.called)
def __init__(self,
project='functest',
case_name='cloudify_ims',
repo='',
cmd=''):
super(CloudifyIms, self).__init__(project, case_name, repo, cmd)
self.logger = ft_logger.Logger(__name__).getLogger()
# Retrieve the configuration
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("cloudify.requirements", config_file),
blueprint=get_config("cloudify.blueprint", config_file),
inputs=get_config("cloudify.inputs", config_file))
self.logger.debug("Orchestrator configuration: %s" % self.orchestrator)
self.vnf = dict(blueprint=get_config("clearwater.blueprint",
config_file),
deployment_name=get_config(
"clearwater.deployment_name", config_file),
inputs=get_config("clearwater.inputs", config_file),
requirements=get_config("clearwater.requirements",
config_file))
self.logger.debug("VNF configuration: %s" % self.vnf)
self.images = get_config("tenant_images", config_file)
self.logger.info("Images needed for vIMS: %s" % self.images)
def __init__(self, project='functest', case_name='', repo='', cmd=''):
super(Feature, self).__init__(case_name=case_name)
self.project_name = project
self.cmd = cmd
self.repo = CONST.__getattribute__(repo)
self.result_file = self.get_result_file()
self.logger = ft_logger.Logger(project).getLogger()
def __init__(self, testcase_dir, inputs={}):
self.testcase_dir = testcase_dir
self.blueprint_dir = testcase_dir + 'cloudify-manager-blueprint/'
self.input_file = 'inputs.yaml'
self.manager_blueprint = False
self.config = inputs
self.logger = ft_logger.Logger("Orchestrator").getLogger()
self.manager_up = False
def __init__(self, case_name=''):
super(SnapsTestRunner, self).__init__(case_name)
self.ext_net_name = snaps_utils.get_ext_net_name()
self.logger = ft_logger.Logger(self.project_name).getLogger()
scenario = functest_utils.get_scenario()
self.flavor_metadata = create_flavor.MEM_PAGE_SIZE_ANY
if 'ovs' in scenario or 'fdio' in scenario:
self.flavor_metadata = create_flavor.MEM_PAGE_SIZE_LARGE
self.logger.info("Using flavor metatdata '%s'" % self.flavor_metadata)
def main():
logger = ft_logger.Logger("vRouter").getLogger()
vrouter = vRouter(logger)
result_data = vrouter.main()
if result_data["status"] == "FAIL":
logger.error("Error : Failed vRouter Run ")
return -1
logger.info("Ok : Success vRouter Run")
return 0
def __init__(self, project='functest', case_name='opera_ims',
repo=CONST.dir_repo_opera, cmd=''):
super(OperaIms, self).__init__(project, case_name, repo, cmd)
self.logger = ft_logger.Logger(__name__).getLogger()
self.ellis_file = os.path.join(self.result_dir, 'ellis.info')
self.live_test_file = os.path.join(self.result_dir,
'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)
class TestcaseBase(object):
EX_OK = os.EX_OK
EX_RUN_ERROR = os.EX_SOFTWARE
EX_PUSH_TO_DB_ERROR = os.EX_SOFTWARE - 1
EX_TESTCASE_FAILED = os.EX_SOFTWARE - 2
logger = ft_logger.Logger(__name__).getLogger()
def __init__(self):
self.details = {}
self.project_name = "functest"
self.case_name = ""
self.criteria = ""
self.start_time = ""
self.stop_time = ""
def check_criteria(self):
try:
assert self.criteria
if self.criteria == 'PASS':
return TestcaseBase.EX_OK
except:
self.logger.error("Please run test before checking the results")
return TestcaseBase.EX_TESTCASE_FAILED
def run(self, **kwargs):
self.logger.error("Run must be implemented")
return TestcaseBase.EX_RUN_ERROR
def push_to_db(self):
try:
assert self.project_name
assert self.case_name
assert self.criteria
assert self.start_time
assert self.stop_time
if ft_utils.push_results_to_db(self.project_name, self.case_name,
self.start_time, self.stop_time,
self.criteria, self.details):
self.logger.info("The results were successfully pushed to DB")
return TestcaseBase.EX_OK
else:
self.logger.error("The results cannot be pushed to DB")
return TestcaseBase.EX_PUSH_TO_DB_ERROR
except Exception:
self.logger.exception("The results cannot be pushed to DB")
return TestcaseBase.EX_PUSH_TO_DB_ERROR
class AaaVnf(vnf_base.VnfOnBoardingBase):
logger = ft_logger.Logger("VNF AAA").getLogger()
def __init__(self):
super(AaaVnf, self).__init__(case_name="aaa")
def deploy_orchestrator(self):
self.logger.info("No VNFM needed to deploy a free radius here")
return None
# TODO see how to use build in exception form releng module
def deploy_vnf(self):
self.logger.info("Freeradius VNF deployment")
# TODO apt-get update + config tuning
deploy_vnf = {}
deploy_vnf['status'] = "PASS"
deploy_vnf['result'] = {}
return deploy_vnf
def test_vnf(self):
self.logger.info("Run test towards freeradius")
# TODO: once the freeradius is deployed..make some tests
test_vnf = {}
test_vnf['status'] = "PASS"
test_vnf['result'] = {}
return test_vnf
def main(self, **kwargs):
self.logger.info("AAA VNF onboarding")
self.execute()
if self.criteria is "PASS":
return self.EX_OK
else:
return self.EX_RUN_ERROR
def run(self):
kwargs = {}
return self.main(**kwargs)
def __init__(self, project='functest', case_name='orchestra_ims',
repo='', cmd=''):
super(ImsVnf, self).__init__(project, case_name, repo, cmd)
self.ob_password = "******"
self.ob_username = "******"
self.ob_https = False
self.ob_port = "8080"
self.ob_ip = "localhost"
self.ob_instance_id = ""
self.logger = ft_logger.Logger("orchestra_ims").getLogger()
self.case_dir = os.path.join(CONST.dir_functest_test, 'vnf/ims/')
self.data_dir = CONST.dir_ims_data
self.test_dir = CONST.dir_repo_vims_test
self.ob_projectid = ""
self.keystone_client = os_utils.get_keystone_client()
self.ob_nsr_id = ""
self.nsr = None
self.main_agent = None
# vIMS Data directory creation
if not os.path.exists(self.data_dir):
os.makedirs(self.data_dir)
# Retrieve the configuration
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.imagename = get_config("openbaton.imagename", config_file)
self.bootstrap_link = get_config("openbaton.bootstrap_link",
config_file)
self.bootstrap_config_link = get_config(
"openbaton.bootstrap_config_link", config_file)
self.market_link = get_config("openbaton.marketplace_link",
config_file)
self.images = get_config("tenant_images", config_file)
self.ims_conf = get_config("vIMS", config_file)
self.userdata_file = get_config("openbaton.userdata.file",
config_file)
import os
import os.path
import subprocess
import sys
import time
from cinderclient import client as cinderclient
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
from glanceclient import client as glanceclient
from keystoneclient.v2_0 import client as keystoneclient
from neutronclient.v2_0 import client as neutronclient
from novaclient import client as novaclient
logger = ft_logger.Logger("openstack_utils").getLogger()
# *********************************************
# CREDENTIALS
# *********************************************
class MissingEnvVar(Exception):
def __init__(self, var):
self.var = var
def __str__(self):
return str.format("Please set the mandatory env var: {}", self.var)
def check_credentials():
"""
# [email protected] # # # All rights reserved. This program and the accompanying materials # are made available under the terms of the Apache License, Version 2.0 # which accompanies this distribution, and is available at # http://www.apache.org/licenses/LICENSE-2.0 # import functest.utils.functest_logger as ft_logger import functest.utils.openstack_utils as os_utils import functest.utils.openstack_tacker as os_tacker import yaml import functest.utils.functest_constants as ft_constants logger = ft_logger.Logger("openstack_snapshot").getLogger() OS_SNAPSHOT_FILE = ft_constants.OPENSTACK_SNAPSHOT_FILE def separator(): logger.info("-------------------------------------------") def get_instances(nova_client): logger.debug("Getting instances...") dic_instances = {} instances = os_utils.get_instances(nova_client) if not (instances is None or len(instances) == 0): for instance in instances: dic_instances.update(
#
#
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Apache License, Version 2.0
# which accompanies this distribution, and is available at
# http://www.apache.org/licenses/LICENSE-2.0
#
import time
import functest.utils.functest_logger as ft_logger
import functest.utils.openstack_utils as os_utils
import functest.utils.openstack_tacker as os_tacker
import yaml
import functest.utils.functest_constants as ft_constants
logger = ft_logger.Logger("openstack_clean").getLogger()
OS_SNAPSHOT_FILE = ft_constants.OPENSTACK_SNAPSHOT_FILE
def separator():
logger.debug("-------------------------------------------")
def remove_instances(nova_client, default_instances):
logger.debug("Removing Nova instances...")
instances = os_utils.get_instances(nova_client)
if instances is None or len(instances) == 0:
logger.debug("No instances found.")
return
def __init__(self):
super(VPingSSH, self).__init__()
self.case_name = 'vping_ssh'
self.logger = ft_logger.Logger(self.case_name).getLogger()
import sys
import fileinput
import yaml
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_utils as os_utils
from functest.utils.constants import CONST
from opnfv.utils import constants as opnfv_constants
from opnfv.deployment import factory
actions = ['start', 'check']
""" logging configuration """
logger = ft_logger.Logger("prepare_env").getLogger()
handler = None
# set the architecture to default
pod_arch = None
arch_filter = ['aarch64']
CONFIG_FUNCTEST_PATH = CONST.CONFIG_FUNCTEST_YAML
CONFIG_PATCH_PATH = os.path.join(os.path.dirname(CONFIG_FUNCTEST_PATH),
"config_patch.yaml")
CONFIG_AARCH64_PATCH_PATH = os.path.join(os.path.dirname(CONFIG_FUNCTEST_PATH),
"config_aarch64_patch.yaml")
RALLY_CONF_PATH = os.path.join("/etc/rally/rally.conf")
RALLY_AARCH64_PATCH_PATH = os.path.join(os.path.dirname(CONFIG_FUNCTEST_PATH),
"rally_aarch64_patch.conf")
# Testcase 1 : Prerequisites configuration for SFC
# Testcase 2 : Creation of 3 VNF Nodes and Attaching Ports
# Testcase 3 : Configure SFC [Port pair,Port Group ,Flow classifer
# Testcase 4 : Configure Port Chain and verify the flows are added.
# Testcase 5 : Verify traffic with VNF node.
# Testcase 6 : Remove the Port Chain and Verify the traffic.
# Testcase 7 : Cleanup
# ###########################################################################
#
import time
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
from sfc_onos import SfcOnos
logger = ft_logger.Logger("sfc").getLogger()
Sfc_obj = SfcOnos()
OK = 200
CREATED = 201
ACCEPTED = 202
NO_CONTENT = 204
start_time = time.time()
def PreConfig():
logger.info("Testcase 1 : Prerequisites configuration for SFC")
logger.info("1.1 Creation of Auth-Token")
check(Sfc_obj.getToken, OK, "Creation of Token")
logger.info("1.2 Creation of Network")
#
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Apache License, Version 2.0
# which accompanies this distribution, and is available at
# http://www.apache.org/licenses/LICENSE-2.0
#
import os
import paramiko
import subprocess
import sys
import functest.utils.functest_logger as ft_logger
logger = ft_logger.Logger(__name__).getLogger()
SFC_REPO_DIR = "/home/opnfv/repos/sfc"
try:
INSTALLER_IP = os.environ['INSTALLER_IP']
except:
logger.debug("INSTALLER_IP does not exist. We create 10.20.0.2")
INSTALLER_IP = "10.20.0.2"
os.environ['ODL_SFC_LOG'] = "/home/opnfv/functest/results/sfc.log"
os.environ['ODL_SFC_DIR'] = os.path.join(SFC_REPO_DIR,
"sfc/tests/functest")
SETUP_SCRIPTS_DIR = os.path.join(os.environ['ODL_SFC_DIR'], 'setup_scripts')
command = SETUP_SCRIPTS_DIR + ("/server_presetup_CI.bash | "
class Client(Environment):
logger = ft_logger.Logger("client").getLogger()
def __init__(self):
Environment.__init__(self)
self.loginfo = Environment()
self.testcase = ''
def RunScript(self, handle, testname, timeout=300):
"""
Run ONOS Test Script
Parameters:
testname: ONOS Testcase Name
masterusername: The server username of running ONOS
masterpassword: The server password of running ONOS
"""
self.testcase = testname
self.ChangeTestCasePara(testname, self.masterusername,
self.masterpassword)
runhandle = handle
runtest = (self.home + "/OnosSystemTest/TestON/bin/cli.py run " +
testname)
runhandle.sendline(runtest)
circletime = 0
lastshowscreeninfo = ''
while True:
Result = runhandle.expect(
["PEXPECT]#", pexpect.EOF, pexpect.TIMEOUT])
curshowscreeninfo = runhandle.before
if (len(lastshowscreeninfo) != len(curshowscreeninfo)):
self.loginfo.log(
str(curshowscreeninfo)[len(lastshowscreeninfo)::])
lastshowscreeninfo = curshowscreeninfo
if Result == 0:
self.logger.info("Done!")
return
time.sleep(1)
circletime += 1
if circletime > timeout:
break
self.loginfo.log("Timeout when running the test, please check!")
def onosstart(self):
# This is the compass run machine user&pass,you need to modify
self.logger.info("Test Begin.....")
self.OnosConnectionSet()
masterhandle = self.SSHlogin(self.localhost, self.masterusername,
self.masterpassword)
self.OnosEnvSetup(masterhandle)
return masterhandle
def onosclean(self, handle):
self.SSHRelease(handle)
self.loginfo.log('Release onos handle Successful')
def push_results_to_db(self, payload, pushornot=1):
if pushornot != 1:
return 1
url = self.Result_DB + "/results"
params = {
"project_name": "functest",
"case_name": "ONOS-" + self.testcase,
"pod_name": 'huawei-build-2',
"details": payload
}
headers = {'Content-Type': 'application/json'}
try:
r = requests.post(url, data=json.dumps(params), headers=headers)
self.loginfo.log(r)
except:
self.loginfo.log('Error pushing results into Database')
class TestCase(object):
"""Parent class of Functest TestCase."""
EX_OK = os.EX_OK
EX_RUN_ERROR = os.EX_SOFTWARE
EX_PUSH_TO_DB_ERROR = os.EX_SOFTWARE - 1
EX_TESTCASE_FAILED = os.EX_SOFTWARE - 2
logger = ft_logger.Logger(__name__).getLogger()
def __init__(self, case_name=""):
self.details = {}
self.project_name = "functest"
self.case_name = case_name
self.criteria = ""
self.start_time = ""
self.stop_time = ""
def check_criteria(self):
"""Interpret the results of TestCase.
It allows getting the results of TestCase. It completes run()
which only returns the execution status.
It can be overriden if checking criteria is not suitable.
Returns:
TestCase.EX_OK if criteria is 'PASS'.
TestCase.EX_TESTCASE_FAILED otherwise.
"""
try:
assert self.criteria
if self.criteria == 'PASS':
return TestCase.EX_OK
except AssertionError:
self.logger.error("Please run test before checking the results")
return TestCase.EX_TESTCASE_FAILED
def run(self, **kwargs):
"""Run TestCase.
It allows running TestCase and getting its execution
status.
The subclasses must override the default implementation which
is false on purpose. The only prerequisite is to set the
following attributes to push the results to DB:
* case_name,
* criteria,
* start_time,
* stop_time.
Args:
**kwargs: Arbitrary keyword arguments.
Returns:
TestCase.EX_RUN_ERROR.
"""
# pylint: disable=unused-argument
self.logger.error("Run must be implemented")
return TestCase.EX_RUN_ERROR
def push_to_db(self):
"""Push the results of TestCase to the DB.
It allows publishing the results and to check the status.
It could be overriden if the common implementation is not
suitable. The following attributes must be set before pushing
the results to DB:
* project_name,
* case_name,
* criteria,
* start_time,
* stop_time.
Returns:
TestCase.EX_OK if results were pushed to DB.
TestCase.EX_PUSH_TO_DB_ERROR otherwise.
"""
try:
assert self.project_name
assert self.case_name
assert self.criteria
assert self.start_time
assert self.stop_time
if ft_utils.push_results_to_db(self.project_name, self.case_name,
self.start_time, self.stop_time,
self.criteria, self.details):
self.logger.info("The results were successfully pushed to DB")
return TestCase.EX_OK
else:
self.logger.error("The results cannot be pushed to DB")
return TestCase.EX_PUSH_TO_DB_ERROR
except Exception: # pylint: disable=broad-except
self.logger.exception("The results cannot be pushed to DB")
return TestCase.EX_PUSH_TO_DB_ERROR
# This program and the accompanying materials
# are made available under the terms of the Apache License, Version 2.0
# which accompanies this distribution, and is available at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
import sys
import time
import functest.utils.functest_logger as ft_logger
import functest.utils.openstack_utils as os_utils
import re
from sdnvpn.lib import config as sdnvpn_config
logger = ft_logger.Logger("sndvpn_test_utils").getLogger()
common_config = sdnvpn_config.CommonConfig()
def create_net(neutron_client, name):
logger.debug("Creating network %s", name)
net_id = os_utils.create_neutron_net(neutron_client, name)
if not net_id:
logger.error(
"There has been a problem when creating the neutron network")
sys.exit(-1)
return net_id
def create_subnet(neutron_client, name, cidr, net_id):
import sys
import time
import yaml
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
from sdnvpn.lib import config as sdnvpn_config
parser = argparse.ArgumentParser()
parser.add_argument("-r", "--report",
help="Create json result file",
action="store_true")
args = parser.parse_args()
logger = ft_logger.Logger("sdnvpn-run-tests").getLogger()
COMMON_CONFIG = sdnvpn_config.CommonConfig()
TEST_DB_URL = COMMON_CONFIG.test_db
def push_results(testname, start_time, end_time, criteria, details):
logger.info("Push testcase '%s' results into the DB...\n" % testname)
ft_utils.push_results_to_db("sdnvpn",
testname,
start_time,
end_time,
criteria,
details)
import functest.utils.openstack_utils as openstack_utils
pp = pprint.PrettyPrinter(indent=4)
parser = argparse.ArgumentParser()
image_exists = False
parser.add_argument("-d", "--debug", help="Debug mode", action="store_true")
parser.add_argument("-r", "--report",
help="Create json result file",
action="store_true")
args = parser.parse_args()
""" logging configuration """
logger = ft_logger.Logger("vping_userdata").getLogger()
REPO_PATH = os.environ['repos_dir'] + '/functest/'
if not os.path.exists(REPO_PATH):
logger.error("Functest repository directory not found '%s'" % REPO_PATH)
exit(-1)
with open(os.environ["CONFIG_FUNCTEST_YAML"]) as f:
functest_yaml = yaml.safe_load(f)
f.close()
HOME = os.environ['HOME'] + "/"
# vPing parameters
VM_BOOT_TIMEOUT = 180
VM_DELETE_TIMEOUT = 100
PING_TIMEOUT = functest_yaml.get("vping").get("ping_timeout")
# Wrappers for trozet's python-tackerclient v1.0
# (https://github.com/trozet/python-tackerclient)
#
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Apache License, Version 2.0
# which accompanies this distribution, and is available at
# http://www.apache.org/licenses/LICENSE-2.0
##########################################################################
from tackerclient.v1_0 import client as tackerclient
import functest.utils.functest_logger as ft_logger
import functest.utils.openstack_utils as os_utils
import time
logger = ft_logger.Logger("tacker_utils").getLogger()
def get_tacker_client(other_creds={}):
sess = os_utils.get_session(other_creds)
return tackerclient.Client(session=sess)
# *********************************************
# TACKER
# *********************************************
def get_id_from_name(tacker_client, resource_type, resource_name):
try:
req_params = {'fields': 'id', 'name': resource_name}
endpoint = '/{0}s'.format(resource_type)
resp = tacker_client.get(endpoint, params=req_params)
parser.add_argument("-z",
"--sanity",
help="Sanity test mode, execute only a subset of tests",
action="store_true")
args = parser.parse_args()
client_dict = {}
network_dict = {}
if args.verbose:
RALLY_STDERR = subprocess.STDOUT
else:
RALLY_STDERR = open(os.devnull, 'w')
""" logging configuration """
logger = ft_logger.Logger("run_rally").getLogger()
REPO_PATH = os.environ['repos_dir'] + '/functest/'
if not os.path.exists(REPO_PATH):
logger.error("Functest repository directory not found '%s'" % REPO_PATH)
exit(-1)
with open(os.environ["CONFIG_FUNCTEST_YAML"]) as f:
functest_yaml = yaml.safe_load(f)
f.close()
HOME = os.environ['HOME'] + "/"
RALLY_DIR = REPO_PATH + functest_yaml.get("general").get("directories").get(
"dir_rally")
TEMPLATE_DIR = RALLY_DIR + "scenario/templates"
SUPPORT_DIR = RALLY_DIR + "scenario/support"
import functest.utils.openstack_utils as os_utils
from sdnvpn.lib import utils as test_utils
from sdnvpn.lib import config as sdnvpn_config
from sdnvpn.lib.results import Results
parser = argparse.ArgumentParser()
parser.add_argument("-r",
"--report",
help="Create json result file",
action="store_true")
args = parser.parse_args()
logger = ft_logger.Logger("sdnvpn-testcase-4").getLogger()
COMMON_CONFIG = sdnvpn_config.CommonConfig()
TESTCASE_CONFIG = sdnvpn_config.TestcaseConfig('testcase_4')
def main():
results = Results(COMMON_CONFIG.line_length)
results.add_to_summary(0, "=")
results.add_to_summary(2, "STATUS", "SUBTEST")
results.add_to_summary(0, "=")
nova_client = os_utils.get_nova_client()
neutron_client = os_utils.get_neutron_client()
glance_client = os_utils.get_glance_client()
import argparse
import datetime
import os
import re
import time
import yaml
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as functest_utils
parser = argparse.ArgumentParser()
parser.add_argument("-i", "--installer", help="Installer type")
args = parser.parse_args()
""" logging configuration """
logger = ft_logger.Logger("onos").getLogger()
with open(os.environ["CONFIG_FUNCTEST_YAML"]) as f:
functest_yaml = yaml.safe_load(f)
f.close()
# onos parameters
TEST_DB = functest_yaml.get("results").get("test_db_url")
ONOS_REPO_PATH = functest_yaml.get("general").get("directories").get(
"dir_repos")
ONOS_CONF_DIR = functest_yaml.get("general").get("directories").get(
"dir_functest_conf")
REPO_PATH = ONOS_REPO_PATH + '/functest/'
if not os.path.exists(REPO_PATH):
logger.error("Functest repository directory not found '%s'" % REPO_PATH)
exit(-1)
action='store',
help="Test case or tier (group of tests) to be executed. "
"It will run all the test if not specified.")
parser.add_argument("-n",
"--noclean",
help="Do not clean OpenStack resources"
" after running each test (default=false).",
action="store_true")
parser.add_argument("-r",
"--report",
help="Push results to database "
"(default=false).",
action="store_true")
args = parser.parse_args()
""" logging configuration """
logger = ft_logger.Logger("run_tests").getLogger()
""" global variables """
EXEC_SCRIPT = ("%s/functest/ci/exec_test.sh" % ft_constants.FUNCTEST_REPO_DIR)
# This will be the return code of this script. If any of the tests fails,
# this variable will change to -1
class GlobalVariables:
EXECUTED_TEST_CASES = []
OVERALL_RESULT = 0
CLEAN_FLAG = True
REPORT_FLAG = False
def print_separator(str, count=45):
import shutil
import subprocess
import sys
import time
import urllib2
from datetime import datetime as dt
import dns.resolver
import requests
import yaml
from git import Repo
from functest.utils import decorators
import functest.utils.functest_logger as ft_logger
logger = ft_logger.Logger("functest_utils").getLogger()
# ----------------------------------------------------------
#
# INTERNET UTILS
#
# -----------------------------------------------------------
def check_internet_connectivity(url='http://www.opnfv.org/'):
"""
Check if there is access to the internet
"""
try:
urllib2.urlopen(url, timeout=5)
return True
except urllib2.URLError:
