def __init__(self):
"""
set basic object variables
"""
super(OpenShiftHelper, self).__init__()
self.name = None
self.icontainer = self.get_url()
self.template = self.get_template()
self.pod_id = None
self._ip_address = None
if not self.icontainer:
raise ConfigExc(
"No container image specified in the configuration file or environment variable."
)
if "docker=" in self.icontainer:
self.container_name = self.icontainer[7:]
else:
# untrusted source
self.container_name = self.icontainer
# application name is taken from docker.io/modularitycontainer/memcached
self.app_name = self.container_name.split('/')[-1]
self.app_ip = None
random_str = ''.join(random.choice(string.lowercase) for _ in range(3))
self.project_name = "{project}-{random_str}".format(
project=self.app_name, random_str=random_str)
common.print_debug(self.icontainer, self.app_name)
def start(self, command="/bin/bash"):
"""
starts the OpenShift application
:param command: Do not use it directly (It is defined in config.yaml)
:return: None
"""
# Clean environment before running tests
try:
self._app_remove()
except Exception as e:
common.print_info(e, "OpenShift applications were removed")
pass
project = self.runHost('oc new-project %s' % self.project_name,
ignore_status=True,
verbose=common.is_not_silent())
if self.template is None:
if not self._app_exists():
# This part is used for running an application without template or s2i
self._create_app()
else:
common.print_debug(self.template)
self._change_openshift_account(
account=common.get_openshift_user(),
password=common.get_openshift_passwd())
self._remove_apps_from_openshift_resources(common.TEMPLATE)
if not self._create_app_by_template():
return False
# Verify application is really deploy and prepared for testing.
if not self._verify_pod():
return False
self._get_ip_instance()
def _get_openshift_template(self):
"""
Function returns template name from OpenShift environment
:return: dictionary
"""
template_name = self._oc_get_output('template')
common.print_debug(template_name)
def __oc_status(self):
oc_status = self.runHost("oc status",
ignore_status=True,
verbose=common.is_not_silent())
common.print_debug(oc_status.stdout)
common.print_debug(oc_status.stderr)
return oc_status.exit_status
def testPaths(self):
self.start()
allpackages = filter(bool, self.run("rpm -qa").stdout.split("\n"))
common.print_debug(allpackages)
for package in allpackages:
if 'filesystem' in package:
continue
for package_file in filter(bool, self.run("rpm -ql %s" % package).stdout.split("\n")):
if not self._compare_fhs(package_file):
self.fail("(%s): File [%s] violates the FHS." % (package, package_file))
def _tcinfo(self, testcases, header, logs=True, description=True):
"""
Parse testcases dics and print output for them in nicer format
Main purpose is to display docstrings of testcases for failures
example:
def test_some(something)
'''
This is line1.
This is line2.
:return: None
'''
self.assertTrue(False, msg="This is fail reason")
procudes line: desc -> This is line1. This is line2.
reason -> This is fail reason
:param testcases: dict of testcases
:param header: str what to print as header
:param logs: boolean if print logs for these testcases (default True)
:param description: boolean if print description = docs strings for test class + function
:return: None
"""
if testcases:
emptydelimiter = ""
harddelimiter = "------------------------"
common.print_info(emptydelimiter, "{0} {1} {0}".format(harddelimiter, header))
for testcase in testcases:
tcname = testcase
if re.search('^[0-9]+-', testcase.get('id',"")):
tcname = testcase.get('id').split("-", 1)[1]
tcnameoutput = tcname
splitted = re.search("(.*):(.+)\.(.+)$", tcname)
if splitted:
docstrcls = []
docstrtst = []
testfile, classname, fnname = splitted.groups()
try:
testmodule = imp.load_source("test", testfile)
if getattr(testmodule, classname).__doc__:
docstrcls = getattr(testmodule, classname).__doc__.strip().split("\n")
if getattr(getattr(testmodule, classname), fnname).__doc__:
docstrtst = getattr(getattr(testmodule, classname), fnname).__doc__.strip().split("\n")
tcnameoutput = " ".join([x for x in docstrcls + docstrtst if not re.search(":.*:", x)])
# TODO: replace more whitespaces just by one - we should find better solution how to that
tcnameoutput = ' '.join(tcnameoutput.split())
except Exception as e:
common.print_debug("(INFO) Error happen when parsing testcase name ({})".format(tcname), e)
pass
common.print_info("TEST {0}: {1}".format(testcase.get('status'), tcname))
if description and tcnameoutput!=tcname and tcnameoutput and tcnameoutput.strip():
common.print_info(" desc -> {0}".format(tcnameoutput))
if testcase.get('fail_reason') and testcase.get('fail_reason') != "None":
common.print_info(" reason -> {0}".format(testcase.get('fail_reason')))
if logs:
common.print_info(" {0}".format(testcase.get('logfile')))
common.print_info(emptydelimiter)
def cli():
# unknown options are forwarded to avocado run
args, unknown = mtfparser().parse_known_args()
if args.version:
print "0.7.7"
exit(0)
# uses additional arguments, set up variable asap, its used afterwards:
if args.debug:
os.environ['DEBUG'] = 'yes'
os.environ['AVOCADO_LOG_DEBUG'] = 'yes'
if args.config:
os.environ['CONFIG'] = args.config
if args.url:
os.environ['URL'] = args.url
if args.modulemdurl:
os.environ['MODULEMDURL'] = args.modulemdurl
common.print_debug(
"Options: linter={0}, setup={1}, action={2}, module={3}".format(
args.linter, args.setup, args.action, args.module))
common.print_debug(
"remaining options for avocado or test files: {0}".format(unknown))
# environment usage:
# read: os.environ.get('MODULE')
# write: os.environ['MODULE']
# MODULE could be from:
# 1. common.get_module_type() ... it reads config.yaml and treceback if it doesn't exist
# 2. environment ... MODULE=docker etc
# 3. argument ... --module=docker
try:
args.module = common.get_module_type()
# TODO it wrongly writes: 'Using default minimal config ...', change in common.py
except moduleframework.mtfexceptions.ModuleFrameworkException:
pass
if os.environ.get('MODULE') is not None:
# environment is the highest priority because mtf uses environment (too much)
args.module = os.environ['MODULE']
if args.module:
# setup also environment
os.environ['MODULE'] = args.module
if args.module in common.get_backend_list():
# for debug purposes, to be sure about module variables or options
common.print_debug("MODULE={0}, options={1}".format(
os.environ.get('MODULE'), args.module))
else:
# TODO: what to do here? whats the defaults value for MODULE, do I know it?
common.print_info(
"MODULE={0} ; we support {1} \n === expecting your magic, enjoy! === "
.format(os.environ.get('MODULE'), common.get_backend_list()))
common.print_debug("MODULE={0}".format(os.environ.get('MODULE')))
return args, unknown
def avocado_general(self):
# additional parameters
# self.additionalAvocadoArg: its from cmd line, whats unknown to this tool
avocado_args = "" # when needed => specify HERE your additional stuff
avocadoAction = "avocado {ACTION} {AVOCADO_ARGS}".format(
ACTION=self.args.action, AVOCADO_ARGS=avocado_args)
bash = process.run("{AVOCADO} {a} {b}".format(
AVOCADO=avocadoAction,
a=self.additionalAvocadoArg,
b=" ".join(self.tests)),
shell=True,
ignore_status=True)
common.print_info(bash.stdout, bash.stderr)
common.print_debug("Command used: ", bash.command)
return bash.exit_status
def _get_pod_status(self):
"""
This method checks if the POD is running within OpenShift environment.
:return: True if POD is running with status "Running"
False all other statuses
"""
pod_initiated = False
for pod in self._oc_get_output('pod'):
common.print_debug(self.pod_id)
if self._check_resource_in_json(pod):
self._pod_status = pod.get('status').get('phase')
if self._pod_status == "Running":
pod_initiated = True
break
return pod_initiated
def main():
common.print_debug('verbose/debug mode')
args, unknown = cli()
if args.setup:
# mtfenvset need bash environment!
from moduleframework.mtf_environment import mtfenvset
mtfenvset()
a = AvocadoStart(args, unknown)
if args.action == 'run':
returncode = a.avocado_run()
a.show_error()
else:
# when there is any need, change general method or create specific one:
returncode = a.avocado_general()
exit(returncode)
def avocado_run(self):
self.json_tmppath = tempfile.mktemp()
avocado_args = "--json {JSON_LOG}".format(JSON_LOG=self.json_tmppath)
if self.args.xunit:
avocado_args += " --xunit {XUNIT} ".format(XUNIT=self.args.xunit)
avocadoAction = "avocado {ACTION} {AVOCADO_ARGS}".format(
ACTION=self.args.action, AVOCADO_ARGS=avocado_args)
# run avocado with right cmd arguments
bash = process.run("{AVOCADO} {a} {b}".format(
AVOCADO=avocadoAction,
a=self.additionalAvocadoArg,
b=" ".join(self.tests)),
shell=True,
ignore_status=True)
common.print_info(bash.stdout, bash.stderr)
common.print_debug("Command used: ", bash.command)
return bash.exit_status
def _create_app(self, template=None):
"""
It creates an application in OpenShift environment
:param template: If parameter present, then create an application from template
:return: Exit status of oc new-app.
"""
cmd = ["oc", "new-app"]
if template is None:
cmd.append(self.container_name)
else:
cmd.extend([template, "-p", "APPLICATION_NAME=%s" % self.app_name])
cmd.extend(["-l", "mtf_testing=true"])
cmd.extend(["--name", self.app_name])
common.print_debug(cmd)
oc_new_app = self.runHost(' '.join(cmd), ignore_status=True)
time.sleep(1)
common.print_debug(oc_new_app.stdout)
return oc_new_app.exit_status
def __init__(self, args, unknown):
# choose between TESTS and ADDITIONAL ENVIRONMENT from options
if args.linter:
self.tests.append("{MTF_TOOLS}/*.py".format(
MTF_TOOLS=metadata_common.MetadataLoaderMTF.MTF_LINTER_PATH))
self.args = args
for param in unknown:
# take care of this, see tags for safe/unsafe:
# http://avocado-framework.readthedocs.io/en/52.0/WritingTests.html#categorizing-tests
if os.path.exists(param):
# this is list of tests in local file
self.tests.append(param)
else:
# this is additional avocado param
self.additionalAvocadoArg += " {0} ".format(param)
if self.args.metadata:
common.print_info("Using Metadata loader for tests and filtering")
metadata_tests = filtertests(backend="mtf",
location=os.getcwd(),
linters=False,
tests=[],
tags=[],
relevancy="")
tests_dict = [x[metadata_common.SOURCE] for x in metadata_tests]
self.tests += tests_dict
common.print_debug("Loaded tests via metadata file: %s" %
tests_dict)
common.print_debug("tests = {0}".format(self.tests))
common.print_debug("additionalAvocadoArg = {0}".format(
self.additionalAvocadoArg))
def __init__(self):
"""
set basic object variables
"""
super(OpenShiftHelper, self).__init__()
self.name = None
self.icontainer = self.get_url()
self.pod_id = None
self._pod_status = None
if not self.icontainer:
raise ConfigExc(
"No container image specified in the configuration file or environment variable."
)
if "docker=" in self.icontainer:
self.container_name = self.icontainer[7:]
else:
# untrusted source
self.container_name = self.icontainer
# application name is taken from docker.io/modularitycontainer/memcached
self.app_name = self.container_name.split('/')[-1]
self.app_ip = None
common.print_debug(self.icontainer, self.app_name)
