def target(*a, **kw):
listener = allure_robotframework(logger_path=allure_dir)
with open(stdout_file, 'w+') as stdout:
options = {"listener": listener, "outputdir": output_dir, "stdout": stdout}
options.update(kw)
run(*a, **options)
def test_original_signal_handlers_are_restored(self):
my_sigterm = lambda signum, frame: None
signal.signal(signal.SIGTERM, my_sigterm)
run(join(ROOT, 'atest', 'testdata', 'misc', 'pass_and_fail.txt'),
stdout=StringIO(), output=None, log=None, report=None)
assert_equals(signal.getsignal(signal.SIGINT), self.orig_sigint)
assert_equals(signal.getsignal(signal.SIGTERM), my_sigterm)
def run_suites(test_dir, suites, out_dir="./outputs", **options):
# TODO: add logic
try:
for f in os.listdir(out_dir):
os.remove('/'.join((out_dir, f)))
except OSError:
pass
if not os.path.exists(out_dir):
os.makedirs(out_dir)
for s in suites:
longname = s.longname
varfile = []
varfile.append('resources/libraries/python/topology.py')
# TODO: check testcases Tags
with open('{}/{}.out'.format(out_dir, longname), 'w') as out, \
open('{}/{}.log'.format(out_dir, longname), 'w') as debug:
robot.run(test_dir,
suite=[longname],
output='{}/{}.xml'.format(out_dir, longname),
debugfile=debug,
log=None,
report=None,
stdout=out,
variablefile=varfile,
**options)
def run_robot(path, **kw):
# ToDo: fix it (_core not works correctly with multiprocessing)
# import six
# import allure_commons
# if six.PY2:
# reload(allure_commons._core)
# else:
# import importlib
# importlib.reload(allure_commons._core)
#
#
from allure_robotframework import allure_robotframework
listener = allure_robotframework(logger_path=tmp_path)
stdout_file = os.path.abspath(
os.path.join(tmp_path, "..", "stdout.txt"))
output_path = os.path.abspath(os.path.join(tmp_path, ".."))
with open(stdout_file, 'w+') as stdout:
options = {
"listener": listener,
"outputdir": output_path,
"stdout": stdout,
"extension": "rst"
}
options.update(kw)
run(path, **options)
def run_suite_option(suite_name):
"""Run Specified Test Suite and creates the results structure
Args:
suite_name: name of the suite that will be executed
"""
# Get suite details
suite = common.Suite(suite_name, MAIN_SUITE)
# Create results directory if does not exist
results_dir = common.check_results_dir(SUITE_DIR)
# Create output directory to store execution results
output_dir = common.create_output_dir(results_dir, suite.name)
# Create a link pointing to the latest run
common.link_latest_run(SUITE_DIR, output_dir)
# Updating config.ini LOG_PATH variable with output_dir
config_path = os.path.join(SUITE_DIR, 'Config', 'config.ini')
update_config_ini(config_ini=config_path, LOG_PATH=output_dir)
# Select tags to be used, empty if not set to execute all
if ARGS.tags:
include_tags = ARGS.tags
else:
include_tags = ''
# Run sxt-test-suite using robot framework
robot.run(suite.path,
outputdir=output_dir,
debugfile=LOG_NAME,
variable='LOGS_DIR:{}'.format(output_dir),
include=include_tags)
def run_robot(targets, report_file, iteration_limit, duration_limit):
listener = TaurusListener(report_file)
listener.prepare()
stdout = StringIO()
stderr = StringIO()
start_time = int(time.time())
iteration = 0
try:
while True:
run(
*targets,
listener=listener, # pass Taurus listener
output=None,
log=None,
report=None, # mute default reporting
stdout=stdout,
stderr=stderr) # capture stdout/stderr
iteration += 1
if 0 < duration_limit < int(time.time()) - start_time:
break
if iteration >= iteration_limit:
break
finally:
listener.post_process()
sys.stdout.write("Robot stdout:\n" + stdout.getvalue() + "\n")
sys.stderr.write("Robot stderr:\n" + stderr.getvalue() + "\n")
if listener.get_test_count() == 0:
raise ValueError("Nothing to test. No tests were found.")
async def start_robot(data):
print('start_robot event called')
with open(join(log_dir, 'robot.log'), 'w') as log_file:
template_path = join(template_dir, data['template_name'])
print('Robot {0} will be executed.'.format(template_path))
robot.run(template_path, stdout=log_file, outputdir=log_dir)
print('Execution done')
def run_robot(targets, report_file, iteration_limit, duration_limit, variablefile, include):
listener = TaurusListener(report_file)
listener.prepare()
stdout = StringIO()
stderr = StringIO()
start_time = int(time.time())
iteration = 0
try:
while True:
kwargs = {
'listener': listener, # pass Taurus listener
'output': None, 'log': None, 'report': None, # mute default reporting
'stdout': stdout, 'stderr': stderr, # capture stdout/stderr
}
if variablefile is not None:
kwargs['variablefile'] = variablefile
if include is not None:
kwargs['include'] = include
run(*targets, **kwargs)
iteration += 1
if 0 < duration_limit < int(time.time()) - start_time:
break
if iteration >= iteration_limit:
break
finally:
listener.post_process()
sys.stdout.write("Robot stdout:\n" + stdout.getvalue() + "\n")
sys.stderr.write("Robot stderr:\n" + stderr.getvalue() + "\n")
if listener.get_test_count() == 0:
raise ValueError("Nothing to test. No tests were found.")
def execute_robot_run(request_id, test_suite, testcase, variables_file_path):
output_dir = os.getenv(
'OPEN_CLI_HOME') + '/data/executions/' + request_id + '/logs'
with open('run.txt', 'w') as output:
if (variables_file_path):
run(test_suite,
report=None,
log=None,
test=testcase,
variablefile=variables_file_path,
stdout=output,
stderr=output,
outputdir=output_dir)
else:
run(test_suite,
report=None,
log=None,
test=testcase,
stdout=output,
stderr=output,
outputdir=output_dir)
if os.path.exists('run.txt'):
with open('run.txt', 'r') as log:
print(log.read())
os.remove('run.txt')
def run_suites(test_dir, suites, out_dir="./outputs", **options):
# TODO: add logic
try:
for f in os.listdir(out_dir):
os.remove('/'.join((out_dir, f)))
except OSError:
pass
if not os.path.exists(out_dir):
os.makedirs(out_dir)
for s in suites:
longname = s.longname
varfile=[]
varfile.append('resources/libraries/python/topology.py')
# TODO: check testcases Tags
with open('{}/{}.out'.format(out_dir, longname), 'w') as out, \
open('{}/{}.log'.format(out_dir, longname), 'w') as debug:
robot.run(test_dir,
suite=[longname],
output='{}/{}.xml'.format(out_dir, longname),
debugfile=debug,
log=None,
report=None,
stdout=out,
variablefile=varfile,
**options)
def main():
#Push required data in builtins
from optparse import OptionParser
parser = OptionParser()
parser.add_option("-t", "--test", dest="testlist", help="Specify file path of TestList to be executed", metavar="path-to-file")
parser.add_option("-b", "--browser", action="store", dest="browser")
parser.add_option("-i", "--includetag", dest="testincludetags", default=False, help="Run tests of given tag only")
parser.add_option("-e", "--excludetag", dest="testexcludetags", default=False, help="Exclude tests of given tag")
parser.add_option("-r", "--rungiventests", dest="rungiventests", default=False, help="Execute only given test case from suite")
parser.add_option("-m", "--randomize",action="store_true", dest="runrandomize", default=False, help="Randomizes the test execution order")
parser.add_option("-f", "--exitonfailure",action="store_true", dest="exitonfailure", default=False, help="Exit suite if test failed")
parser.add_option("-s", "--runsuite", action="store", dest="runsuitesetup", help="Run suite setup")
parser.add_option("-g", "--debugfile", action="store_true", dest="debugfile", default=False, help="Create debug log file")
parser.add_option("-u", "--baseurl", action="store", dest="baseurl")
parser.add_option("-n", "--TestName", action="store", dest="test_name")
parser.add_option("-M", "--MetaData", action="store", dest="metadata")
# parser.add_option("-a", "--abortonfailure", action="store_true", dest="abortonfailure", default=False, help="Abort suite on first test failure ")
s,remainder = parser.parse_args()
global tr
tr = os.getcwd()
from robot import pythonpathsetter
pythonpathsetter.add_path(tr)
robot.run(s.testlist)
def run_robot(targets, report_file, iteration_limit, duration_limit, variablefile):
listener = TaurusListener(report_file)
listener.prepare()
stdout = StringIO()
stderr = StringIO()
start_time = int(time.time())
iteration = 0
try:
while True:
kwargs = {
'listener': listener, # pass Taurus listener
'output': None, 'log': None, 'report': None, # mute default reporting
'stdout': stdout, 'stderr': stderr, # capture stdout/stderr
}
if variablefile is not None:
kwargs['variablefile'] = variablefile
run(*targets, **kwargs)
iteration += 1
if 0 < duration_limit < int(time.time()) - start_time:
break
if iteration >= iteration_limit:
break
finally:
listener.post_process()
sys.stdout.write("Robot stdout:\n" + stdout.getvalue() + "\n")
sys.stderr.write("Robot stderr:\n" + stderr.getvalue() + "\n")
if listener.get_test_count() == 0:
raise ValueError("Nothing to test. No tests were found.")
def runCase(run_id, case_id, build_id, environment_id, environment_name='cdh',\
varfile='/var/dt/tf/etc/environments/cdh.py', testcasename='REST API Ping',\
product_version='3.2.0',build_name='3.2.0'):
"""runs a test case, given these parameters:
run_id,case_id,build_id,environment_id,environment_name='<as it appears in
testopia>',varfile='<full path to file>',testcasename
"""
#print product_version
lockfile = '/var/dt/tf/tmp/locks/' + environment_name + '.lock'
HookInit = HookFW(lockfile, 5, 600)
logdir = '/var/dt/tf/logs/' + str(run_id) + '/' + str(case_id)
stdoutfile = logdir + '/stdout.txt'
listenerfile = '/var/dt/tf/lib/integration/PythonListener.py:'
listenerargs = str(run_id) + ":" + str(case_id) + ":" + str(build_id) + \
":" + str(environment_id)
prodvar = 'dt_version="' + product_version.strip() + '"\n'
#print prodvar
buildvar = 'dt_build_name ="' + build_name.strip() + '"\n'
lstrnr = listenerfile + listenerargs
if HookInit.lockLoop():
print("Locked it , %s" % time.ctime())
os.makedirs(logdir)
shutil.copy(varfile, logdir)
Vfile = logdir + '/' + os.path.basename(varfile)
with open(Vfile, "a") as varfhandle:
varfhandle.write('\n' + prodvar + buildvar)
varfhandle.close()
with open(stdoutfile, 'w') as stdout:
run('/var/dt/tf/Tests', test=testcasename, variablefile=varfile,\
vel='DEBUG', outputdir=logdir, report='report.html',\
log='log.html', listener=lstrnr, stdout=stdout)
# variable=prodvar)
os.remove(lockfile)
print("Released lock, %s" % time.ctime())
def test_importer_caches_are_cleared_between_runs(self):
data = join(ROOT, 'atest', 'testdata', 'core', 'import_settings.txt')
run(data, outputdir=TEMP, stdout=StringIO(), stderr=StringIO())
lib = self._import_library()
res = self._import_resource()
run(data, outputdir=TEMP, stdout=StringIO(), stderr=StringIO())
assert_true(lib is not self._import_library())
assert_true(res is not self._import_resource())
def test_clear_namespace_between_runs(self):
data = join(ROOT, 'atest', 'testdata', 'variables', 'commandline_variables.html')
rc = run(data, outputdir=TEMP, stdout=StringIO(), stderr=StringIO(),
test=['NormalText'], variable=['NormalText:Hello'])
assert_equals(rc, 0)
rc = run(data, outputdir=TEMP, stdout=StringIO(), stderr=StringIO(),
test=['NormalText'])
assert_equals(rc, 1)
def run_and_analyse_multiple_robottests(self, list_of_testfilename):
list_of_output_xml_files = []
for testfilename in list_of_testfilename:
outputfile = tempfile.mkstemp(suffix='.xml')[1]
robot.run(testfilename, report='NONE', log='NONE', output=outputfile)
list_of_output_xml_files.append(outputfile)
keywords = robot_profiler.analyse_output_xml(list_of_output_xml_files)
return keywords
def test_clear_namespace_between_runs(self):
data = join(ROOT, 'atest', 'testdata', 'variables', 'commandline_variables.html')
rc = run(data, outputdir=TEMP, stdout=StringIO(), stderr=StringIO(),
test=['NormalText'], variable=['NormalText:Hello'])
assert_equals(rc, 0)
rc = run(data, outputdir=TEMP, stdout=StringIO(), stderr=StringIO(),
test=['NormalText'])
assert_equals(rc, 1)
def solve_suite_names(outs_dir, datasources, options):
opts = _options_for_dryrun(options, outs_dir)
run(*datasources, **opts)
output = os.path.join(outs_dir, opts['output'])
suite_names = get_suite_names(output)
if os.path.isfile(output):
os.remove(output)
return sorted(set(suite_names))
def create_new_flight(template):
""" create new flight with robot """
print("create new flight ...")
with open('stdout.txt', 'w') as stdout:
robot.run('robot_files/tests/',
include=[template],
log=None,
stdout=stdout)
def run_robot(root):
args = {
'variable': ['ROOTDIR:' + root],
'variablefile': root + '/' + "env.py",
'suite': 'robot_tests',
'noncritical': 'noncritical'
}
robot.run(root, **args)
def test_importer_caches_are_cleared_between_runs(self):
data = join(ROOT, 'atest', 'testdata', 'core', 'import_settings.txt')
run(data, outputdir=TEMP, stdout=StringIO(), stderr=StringIO())
lib = self._import_library()
res = self._import_resource()
run(data, outputdir=TEMP, stdout=StringIO(), stderr=StringIO())
assert_true(lib is not self._import_library())
assert_true(res is not self._import_resource())
def solve_suite_names(outs_dir, datasources, options):
opts = _options_for_dryrun(options, outs_dir)
run(*datasources, **opts)
output = os.path.join(outs_dir, opts['output'])
suite_names = get_suite_names(output)
if os.path.isfile(output):
os.remove(output)
return suite_names
def solve_suite_names(outs_dir, datasources, options, pabot_args):
if 'suitesfrom' in pabot_args:
return _suites_from_outputxml(pabot_args['suitesfrom'])
opts = _options_for_dryrun(options, outs_dir)
with _with_modified_robot():
run(*datasources, **opts)
output = os.path.join(outs_dir, opts['output'])
suite_names = get_suite_names(output)
return sorted(set(suite_names))
def _run_tests_and_process_output(robot_file):
results = join(CURDIR, "results")
output = join(results, "output.xml")
if exists(results):
rmtree(results)
run(join(CURDIR, robot_file), output=output, log=None, report=None, loglevel="DEBUG")
process_output(output)
rebot(output, outputdir=results)
return output
def solve_suite_names(outs_dir, datasources, options, pabot_args):
if 'suitesfrom' in pabot_args:
return _suites_from_outputxml(pabot_args['suitesfrom'])
opts = _options_for_dryrun(options, outs_dir)
with _with_modified_robot():
run(*datasources, **opts)
output = os.path.join(outs_dir, opts['output'])
suite_names = get_suite_names(output)
return sorted(set(suite_names))
def run_robot(nightly='False', build_id=''):
"""This method used to run the robot framework both test and Contiouns integartion setup """
if not nightly:
now = str(datetime.datetime.now())
test_run_folder = "Robot_Logs" + datetime.datetime.now().strftime(
"%Y%m%d-%H%M%S")
complete_dir_path = os.path.join(os.getcwd(),
"logs" + os.sep + test_run_folder)
os.environ["RESULTS_PATH"] = "%s" % test_run_folder
if not os.path.isdir(complete_dir_path):
os.mkdir(complete_dir_path)
else:
pass
#Export the result directory for the test suite
os.environ["RESULTS_PATH"] = test_run_folder
else:
complete_dir_path = os.path.join(os.getcwd(),
"logs" + os.sep + build_id)
os.environ["RESULTS_PATH"] = "%s" % build_id
if not os.path.isdir(complete_dir_path):
os.mkdir(complete_dir_path)
else:
pass
#Form complete path to store html rport
if nightly:
complete_report_path = os.path.join(complete_dir_path, "report.html")
#Form complete path to store log report
complete_log_path = os.path.join(complete_dir_path, "log.html")
complete_xml_path = os.path.join(complete_dir_path, "output.xml")
else:
complete_report_path = os.path.join(
complete_dir_path, "Functional_" +
datetime.datetime.now().strftime("%Y%m%d-%H%M%S") + ".html")
#Form complete path to store log report
complete_log_path = os.path.join(
complete_dir_path, "Functional_log" +
datetime.datetime.now().strftime("%Y%m%d-%H%M%S") + ".html")
if not nightly:
#start the suite
run("resource/Gluster.robot",
report=complete_report_path,
log=complete_log_path)
else:
run(
# "resource/Login/LoginToWizr.robot",
# "resource/camera/createDelete_Camera.robot",
"resource/Gluster.robot",
report=complete_report_path,
log=complete_log_path,
output=complete_xml_path)
def run_robot(nightly='False', build_id=''):
import os
"""This method used to run the robot framework both test and Contiouns integartion setup """
if not nightly:
now = str(datetime.datetime.now())
test_run_folder = "Robot_Logs" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
complete_dir_path = os.path.join(os.getcwd(), "logs" + os.sep + test_run_folder)
os.environ["RESULTS_PATH"] = "%s" % test_run_folder
if not os.path.isdir(complete_dir_path):
os.mkdir(complete_dir_path)
else:
pass
# Export the result directory for the test suite
os.environ["RESULTS_PATH"] = test_run_folder
else:
complete_dir_path = os.path.join(os.getcwd(), "logs" + os.sep + build_id)
os.environ["RESULTS_PATH"] = "%s" % build_id
if not os.path.isdir(complete_dir_path):
os.mkdir(complete_dir_path)
else:
pass
# Form complete path to store html rport
if nightly:
complete_report_path = os.path.join(complete_dir_path, "report.html")
# Form complete path to store log report
complete_log_path = os.path.join(complete_dir_path, "log.html")
complete_xml_path = os.path.join(complete_dir_path, "output.xml")
else:
complete_report_path = os.path.join(complete_dir_path,
"Functional_" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S") + ".html")
# Form complete path to store log report
complete_log_path = os.path.join(complete_dir_path,
"Functional_log" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S") + ".html")
if not nightly:
# start the suite
run(
"/home/vagrant/uniclair_automation/resource/Uniclair_login_logout.robot",
report=complete_report_path, log=complete_log_path)
else:
import subprocess
import os
run("/home/vagrant/uniclair_automation/resource/Uniclair_login_logout.robot",
report=complete_report_path, log=complete_log_path, output=complete_xml_path)
# run(
# "resource/HomePage_IVtree.robot",
# report=complete_report_path, log=complete_log_path, output=complete_xml_path)complete_xml_path
return
def run_test(testfile):
"""
Execute defined test cases using as parameter received testfile.
@param testfile Test's file path.
"""
global tmpOutputDir, noReport, DRY_RUN
logging.debug("Testing {0}".format(testfile))
if testfile.endswith(".robot"):
robotstart = testfile.find(".robot")
testname = testfile[:robotstart]
profile = "../../config/profiles/Sample_Profile.py"
iterations = "iterations:1"
if tmpOutputDir is None:
tmpOutputDir = OUTPUTDIR
kwargs = {
"outputdir": tmpOutputDir,
"loglevel": args.logLevel,
"variablefile": profile,
"variable": [iterations]
}
if args.include:
kwargs["include"] = args.include
if args.exclude:
kwargs["exclude"] = args.exclude
if args.configFile:
kwargs["variable"].append("PLATCONFIG:" + args.configFile)
kwargs["outputdir"] = tmpOutputDir
if os.path.isdir(testname):
logging.debug(
"Found configuration directory for {0}".format(testname))
for cfg in os.listdir(testname):
cfgIndex = cfg.find(".cfg")
if cfgIndex > 0:
cfgname = cfg[:cfgIndex]
Newtestname = testname + "_" + cfgname
if noReport:
kwargs["output"] = Newtestname + ".xml"
logging.info("Running test {0} using config: {1}".format(
testfile, testname + "/" + cfg))
kwargs["report"] = Newtestname + "_report.html"
kwargs["variable"].append("testcase_cfg:" + testname +
"/" + cfg)
if DRY_RUN is False:
run(testfile, **kwargs)
else:
pass
else:
logging.info("Run test {0}".format(testfile))
if DRY_RUN is False:
logging.debug("Output to {0}, {1}".format(
tmpOutputDir, noReport))
if noReport:
kwargs["output"] = testname + ".xml"
run(testfile, **kwargs)
else:
logging.error("{0} Not a robot file".format(testfile))
def test_original_signal_handlers_are_restored(self):
my_sigterm = lambda signum, frame: None
signal.signal(signal.SIGTERM, my_sigterm)
run(join(ROOT, 'atest', 'testdata', 'misc', 'pass_and_fail.txt'),
stdout=StringIO(),
output=None,
log=None,
report=None)
assert_equals(signal.getsignal(signal.SIGINT), self.orig_sigint)
assert_equals(signal.getsignal(signal.SIGTERM), my_sigterm)
def worker_shop(context=None,
masterip='localhost',
port='',
project_name='',
other_variables=''):
"""worker will say hi with task controller"""
tests = os.path.join(project_name, 'cases')
results_path = os.path.join(project_name, 'results')
#worker_ip = get_ip()
listener = 'robotx.core.distlistener.MultiListener:%s:%s' \
% (masterip, port)
#identity = unicode(worker_ip)
identity = u"%04x-%04x" % (randint(0, 0x10000), randint(0, 0x10000))
context = context or zmq.Context.instance()
# socket for running task
worker = context.socket(zmq.REQ)
# We use a string identity for ease here
#zhelpers.set_id(worker)
worker.setsockopt_string(zmq.IDENTITY, identity)
worker.connect("tcp://%s:%s" % (masterip, port))
# socket for control input
controller = context.socket(zmq.SUB)
cport = str(int(port) - 1)
controller.connect("tcp://%s:%s" % (masterip, cport))
controller.setsockopt(zmq.SUBSCRIBE, b"")
# Process messages from maskter and controller
poller = zmq.Poller()
poller.register(worker, zmq.POLLIN)
poller.register(controller, zmq.POLLIN)
while True:
# Tell the router we're ready for work
worker.send('Ready')
socks = dict(poller.poll())
if socks.get(worker) == zmq.POLLIN:
# Get workload from router, until finished
tag = worker.recv()
#print '\nthe tag name is: %s\n' % tag
with open('/tmp/stdout.txt', 'w') as stdout:
run(
tests,
loglevel='TRACE',
include=tag,
#exclude=['notready'],
noncritical=['noncritical'],
outputdir=results_path,
output=tag,
variable=other_variables,
tagstatexclude='ID_*',
listener=listener,
stdout=stdout,
runemptysuite=True)
# Any waiting controller command acts as 'KILL'
if socks.get(controller) == zmq.POLLIN:
break
def run_and_analyse_multiple_robottests(self, list_of_testfilename):
list_of_output_xml_files = []
for testfilename in list_of_testfilename:
outputfile = tempfile.mkstemp(suffix='.xml')[1]
robot.run(testfilename,
report='NONE',
log='NONE',
output=outputfile)
list_of_output_xml_files.append(outputfile)
keywords = robot_profiler.analyse_output_xml(list_of_output_xml_files)
return keywords
def _run_tests_and_statuschecker(test_file):
curdir = dirname(abspath(__file__))
results = join(curdir, 'results')
output = join(results, 'output.xml')
if exists(results):
rmtree(results)
run(join(curdir, test_file), output=output, log=None, report=None,
loglevel='DEBUG')
call(['python', join(dirname(curdir), 'robotstatuschecker.py'), output])
rebot(output, outputdir=results)
return output
def run_robot(app, doctree, docname):
# Tests can be switched off with a global setting:
if not app.config.sphinxcontrib_robotframework_enabled:
return
# Set up a variable for "the current working directory":
robot_dir = os.path.dirname(os.path.join(app.srcdir, docname))
# Tests can be made conditional by listing artifacts created by the
# tests. When artifacts are listed, tests are only run as long as those
# artifacts don't exist:
creates_paths = [os.path.join(robot_dir, x)
for x in getattr(doctree, '_robot_creates', [])]
missing_paths = [path for path in creates_paths
if not os.path.isfile(path)]
if creates_paths and not missing_paths:
return
# Tests are only run when they are found:
if not hasattr(doctree, '_robot_source'):
return
# Build a test suite:
robot_file = tempfile.NamedTemporaryFile(dir=robot_dir, suffix='.robot')
robot_file.write(doctree._robot_source.encode('utf-8'))
robot_file.flush() # flush buffer into file
# Run the test suite:
options = {
'outputdir': robot_dir,
'output': 'NONE',
'log': 'NONE',
'report': 'NONE',
'variable': [
'%s:%s' % key_value for key_value in
app.config.sphinxcontrib_robotframework_variables.items()
]
}
robot.run(robot_file.name, **options)
# Close the test suite (and delete it, because it's a tempfile):
robot_file.close()
# Re-process images to include robot generated images:
if os.path.sep in docname:
# Because process_images is not designed to be called more than once,
# calling it with docnames with sub-directories needs a bit cleanup:
removable = os.path.dirname(docname) + os.path.sep
for node in doctree.traverse(docutils.nodes.image):
if node['uri'].startswith(removable):
node['uri'] = node['uri'][len(removable):]
app.env.process_images(docname, doctree)
def run_tests():
test_path = os.path.curdir
tmp_path = tempfile.gettempdir()
output_dir = os.path.join(tmp_path, "robotx_test_result")
os.mkdir(output_dir)
output_file = os.path.join(output_dir, "output.xml")
log_file = os.path.join(output_dir, "log.html")
report_file = os.path.join(output_dir, "report.html")
suites = ["test_cmd_*"]
run(test_path, suite=suites, outputdir=output_dir, output=output_file, log=log_file, report=report_file)
def main():
output = '../Logs/unicorn'
robot.run(TEST_TO_RUN, \
loglevel='INFO', \
exitonfailure=True, \
noncritical="non-critical", \
log=output+"_log", \
output=output, \
report=output+"_report", \
timestampoutputs=False, \
exclude="manual_test")
def _run_tests_and_process_output(robot_file):
results = join(CURDIR, "results")
output = join(results, "output.xml")
if exists(results):
rmtree(results)
if RF3:
run(join(CURDIR, robot_file), output=output, log=None, report=None, loglevel="DEBUG", exclude="rf3unsupported")
else:
run(join(CURDIR, robot_file), output=output, log=None, report=None, loglevel="DEBUG")
process_output(output)
rebot(output, outputdir=results)
return output
def index(request):
if request.method == 'POST' and 'benu1' in request.POST:
# import function to run
# from .robot_libs import benu1
# call function
robot.run('robot_libs/benu1.robot', outputdir='robot_libs/log')
#return HttpResponse('Hello')
# return user to required page
#return HttpResponseRedirect(reverse(app_name:view_name)
return render(request, "index.html")
def _run_tests_and_process_output(robot_file):
results = join(CURDIR, 'results')
output = join(results, 'output.xml')
if exists(results):
rmtree(results)
run(join(CURDIR, robot_file),
output=output,
log=None,
report=None,
loglevel='DEBUG')
process_output(output)
rebot(output, outputdir=results)
return output
def _api_run_test(datasources, serial, test, browser='chrome'):
print('test: {}'.format(test))
print('pythonpath: {}'.format(default_pythonpath))
print('datasources: {}'.format(datasources))
fldr = './results/{}/tests/{}'.format(serial, test)
run(datasources,
test=test,
variable=[
'browser:{}'.format(browser), 'region:QA',
'remote_url:http://90tvmcjnkd:4444/wd/hub'
],
outputdir=fldr)
return test
def get(self):
print("Robot parameters received.....")
fw_models = self.get_arguments("fw_model")
print(fw_models)
para_dict = {}
para_dict['equipment_type'] = fw_models
yml = ROBOT_YAML()
with open("parameters.yaml", "w") as fh_para:
yml.dump(para_dict, fh_para)
try:
run(robot_path, variablefile='parameters.yaml')
except KeyboardInterrupt:
print("You have pressed CTRL+C!!!!!")
sys.exit(0)
def test_template(schema_base, temp_dir):
schema_file = os.path.join(VENDOR_DIRECTORY, f"{schema_base}.xsd")
schema = xmlschema.XMLSchema(schema_file)
result_file = os.path.join(temp_dir, "results.xml")
robot.run("test",
listener=JunitListener(result_file, schema_base),
critical="working",
noncritical="notworking",
console="none",
log="NONE",
report="NONE",
output="NONE",
loglevel="NONE")
schema.validate(result_file)
def worker_shop(context=None, masterip='localhost', port='', project_name='',
other_variables=''):
"""worker will say hi with task controller"""
tests = os.path.join(project_name, 'cases')
results_path = os.path.join(project_name, 'results')
#worker_ip = get_ip()
listener = 'robotx.core.distlistener.MultiListener:%s:%s' \
% (masterip, port)
#identity = unicode(worker_ip)
identity = u"%04x-%04x" % (randint(0, 0x10000), randint(0, 0x10000))
context = context or zmq.Context.instance()
# socket for running task
worker = context.socket(zmq.REQ)
# We use a string identity for ease here
#zhelpers.set_id(worker)
worker.setsockopt_string(zmq.IDENTITY, identity)
worker.connect("tcp://%s:%s" % (masterip, port))
# socket for control input
controller = context.socket(zmq.SUB)
cport = str(int(port) - 1)
controller.connect("tcp://%s:%s" % (masterip, cport))
controller.setsockopt(zmq.SUBSCRIBE, b"")
# Process messages from maskter and controller
poller = zmq.Poller()
poller.register(worker, zmq.POLLIN)
poller.register(controller, zmq.POLLIN)
while True:
# Tell the router we're ready for work
worker.send('Ready')
socks = dict(poller.poll())
if socks.get(worker) == zmq.POLLIN:
# Get workload from router, until finished
tag = worker.recv()
#print '\nthe tag name is: %s\n' % tag
with open('/tmp/stdout.txt', 'w') as stdout:
run(tests,
loglevel='TRACE',
include=tag,
#exclude=['notready'],
noncritical=['noncritical'],
outputdir=results_path,
output=tag,
variable=other_variables,
tagstatexclude='ID_*',
listener=listener,
stdout=stdout,
runemptysuite=True)
# Any waiting controller command acts as 'KILL'
if socks.get(controller) == zmq.POLLIN:
break
def launch_robot_test(output, variables, excluded_tags, included_tags):
#excluded_tags = ["flash_sw", "dac_test"]
#included_tags = ["flash_sw"]
robot.run(TEST_TO_RUN, \
loglevel='INFO', \
exitonfailure=True, \
noncritical="non-critical", \
log=output+"_log", \
variable=variables, \
output=output, \
report=output+"_report", \
timestampoutputs=False, \
include=included_tags, \
exclude=excluded_tags)
def test_custom_stdout_and_stderr_with_minimal_implementation(self):
output = StreamWithOnlyWriteAndFlush()
assert_equals(run(self.warn, output='NONE', stdout=output, stderr=output), 0)
self._assert_output(output, [('[ WARN ]', 4), ('[ ERROR ]', 1),
('Warnings And Errors', 3), ('Output:', 1),
('Log:', 0), ('Report:', 0)])
self._assert_outputs()
def run(self, args, opts):
"""Sub command 'check' runner"""
if not opts.cases:
raise UsageError("case path must be set with -c or --cases!")
print " Syntax Checking ".center(70, '*')
print '...'
log_level = 'TRACE'
cases_path = opts.cases
tmp_path = tempfile.gettempdir()
xml_result = os.path.join(tmp_path, "check_result.xml")
output_file = os.path.join(tmp_path, "stdout.txt")
with open(output_file, 'w') as stdout:
dryrun_result = run(cases_path,
dryrun=True,
loglevel=log_level,
log='NONE',
report='NONE',
output=xml_result,
stdout=stdout)
detail_result = ExecutionResult(xml_result)
if opts.is_tcms:
if not opts.plan_id:
raise UsageError("plan id must be set with -p or --planid!")
plan_id = opts.plan_id
tcms = TCMS()
ids = tcms.get_plan_case_ids(plan_id)
detail_result.visit(ResultChecker(ids, plan_id))
elif dryrun_result == 0:
print 'Contratulations, no syntax error'
else:
detail_result.visit(DryRunChecker())
print '\n( No news is good news:) )'
print 'checing result is in the file: %s' % output_file
print ' DONE '.center(70, '*')
def _run_inner(self, fixture, hotspot, test_cases_names, options):
file_name = os.path.splitext(os.path.basename(self.path))[0]
suite_name = RobotTestSuite._create_suite_name(file_name, hotspot)
variables = ['SKIP_RUNNING_SERVER:True', 'DIRECTORY:{}'.format(self.remote_server_directory), 'PORT_NUMBER:{}'.format(options.remote_server_port)]
if hotspot:
variables.append('HOTSPOT_ACTION:' + hotspot)
if options.debug_mode:
variables.append('CONFIGURATION:Debug')
test_cases = [(test_name, '{0}.{1}'.format(suite_name, test_name)) for test_name in test_cases_names]
if fixture:
test_cases = [x for x in test_cases if fnmatch.fnmatch(x[1], fixture)]
if len(test_cases) == 0:
return True
deps = set()
for test_name in (t[0] for t in test_cases):
deps.update(self._get_dependencies(test_name))
if not self._run_dependencies(deps, options):
return False
metadata = 'HotSpot_Action:{0}'.format(hotspot if hotspot else '-')
log_file = os.path.join(options.results_directory, '{0}{1}.xml'.format(file_name, '_' + hotspot if hotspot else ''))
RobotTestSuite.log_files.append(log_file)
return robot.run(self.path, runemptysuite=True, output=log_file, log=None, report=None, metadata=metadata, name=suite_name, variable=variables, noncritical=['non-critical', 'skipped'], exclude=options.exclude, test=[t[1] for t in test_cases]) == 0
def run_test(self, test_path, **options):
self.options = options
status = None
# sets temp dir if outputdir not provided
if 'outputdir' not in self.options:
self.options['outputdir'] = self._get_outputdir(test_path)
# removes output dir if exists
if os.path.exists(self.options['outputdir']):
shutil.rmtree(self.options['outputdir'])
os.makedirs(self.options['outputdir'])
# logs console output to file on ALM execution
if self.alm:
log_path = os.path.join(self.options['outputdir'], 'console.log')
self.console_log = open(log_path, 'a')
sys.__stdout__ = sys.__stderr__ = sys.stdout = self.console_log
# runs robot tests
try:
status = robot.run(test_path, **self.options)
if self.alm:
self.alm['TDOutput'].Print(
'Test Execution Path: %s' % (test_path))
self.alm['TDOutput'].Print(
'Robot Run Completed with %s status' % (status))
except Exception, err:
if self.alm:
self.alm['TDOutput'].Print(
'Error while Robot Run: %s' % (str(err)))
else:
print str(err)
def test_listener_gets_notification_about_log_report_and_output(self):
listener = join(ROOT, 'utest', 'resources', 'Listener.py')
assert_equals(run(self.data, output=OUTPUT_PATH, report=REPORT_PATH,
log=LOG_PATH, listener=listener), 1)
self._assert_outputs(stdout=[('[output {0}]'.format(OUTPUT_PATH), 1),
('[report {0}]'.format(REPORT_PATH), 1),
('[log {0}]'.format(LOG_PATH), 1),
('[listener close]', 1)])
def initialize_robot():
'''
Call this function first to import the robot code and
start it up
'''
import robot
return robot.run()
def generate_suite_names_with_dryrun(outs_dir, datasources, options):
opts = _options_for_dryrun(options, outs_dir)
with _with_modified_robot():
run(*datasources, **opts)
output = os.path.join(outs_dir, opts['output'])
suite_names = get_suite_names(output)
if not suite_names:
stdout_value = opts['stdout'].getvalue()
if stdout_value:
print("[STDOUT] from suite search:")
print(stdout_value)
print("[STDOUT] end")
stderr_value = opts['stderr'].getvalue()
if stderr_value:
print("[STDERR] from suite search:")
print(stderr_value)
print("[STDERR] end")
return list(sorted(set(suite_names)))
def test_pre_rebot_modifier_as_instance(self):
class Modifier(SuiteVisitor):
def __init__(self):
self.tests = []
def visit_test(self, test):
self.tests.append(test.name)
modifier = Modifier()
assert_equals(run(self.data, outputdir=TEMP, log=LOG_PATH, prerebotmodifier=modifier), 1)
assert_equals(modifier.tests, ['Pass', 'Fail'])
self._assert_outputs([('Pass ', 1), ('Fail :: FAIL', 1)])
def test_listener_gets_notification_about_log_report_and_output(self):
listener = join(ROOT, "utest", "resources", "Listener.py")
assert_equals(run(self.data, output=OUTPUT_PATH, report=REPORT_PATH, log=LOG_PATH, listener=listener), 1)
self._assert_outputs(
stdout=[
("[output {0}]".format(OUTPUT_PATH), 1),
("[report {0}]".format(REPORT_PATH), 1),
("[log {0}]".format(LOG_PATH), 1),
("[listener close]", 1),
]
)
def solve_suite_names(outs_dir, datasources, options, pabot_args):
if 'suitesfrom' in pabot_args:
return _suites_from_outputxml(pabot_args['suitesfrom'])
opts = _options_for_dryrun(options, outs_dir)
with _with_modified_robot():
run(*datasources, **opts)
output = os.path.join(outs_dir, opts['output'])
suite_names = get_suite_names(output)
if not suite_names:
stdout_value = opts['stdout'].getvalue()
if stdout_value:
print("[STDOUT] from suite search:")
print(stdout_value)
print("[STDOUT] end")
stderr_value = opts['stderr'].getvalue()
if stderr_value:
print("[STDERR] from suite search:")
print(stderr_value)
print("[STDERR] end")
return sorted(set(suite_names))
def worker_shop(context=None, masterip='localhost', port='', tests=''):
"""worker will say hi with task controller"""
#worker_ip = get_ip()
listener='listenerdemo.MultiListener:%s:%s' % (masterip, port)
#identity = unicode(worker_ip)
identity = u"%04x-%04x" % (randint(0, 0x10000), randint(0, 0x10000))
context = context or zmq.Context.instance()
# socket for running task
worker = context.socket(zmq.REQ)
# We use a string identity for ease here
#zhelpers.set_id(worker)
worker.setsockopt_string(zmq.IDENTITY, identity)
worker.connect("tcp://%s:%s" % (masterip, port))
# socket for control input
controller = context.socket(zmq.SUB)
cport = str(int(port) - 1)
controller.connect("tcp://%s:%s" % (masterip, cport))
controller.setsockopt(zmq.SUBSCRIBE, b"")
# Process messages from maskter and controller
poller = zmq.Poller()
poller.register(worker, zmq.POLLIN)
poller.register(controller, zmq.POLLIN)
while True:
# Tell the router we're ready for work
worker.send('Ready')
socks = dict(poller.poll())
if socks.get(worker) == zmq.POLLIN:
# Get workload from router, until finished
tag = worker.recv()
#print '\nthe tag name is: %s\n' % tag
with open('stdout.txt', 'w') as stdout:
run(tests,
loglevel='TRACE',
listener=listener,
output=tag,
stdout=stdout,
include=tag)
# Any waiting controller command acts as 'KILL'
if socks.get(controller) == zmq.POLLIN:
break
def run_tests(self):
data = join(ROOT, "atest", "testdata", "misc", "pass_and_fail.robot")
assert_equals(
run(
data,
timestampoutputs=True,
outputdir=TEMP,
output="output-ts.xml",
report="report-ts.html",
log="log-ts",
),
1,
)
def run_robot(path, **kw):
# ToDo: fix it (_core not works correctly with multiprocessing)
# import six
# import allure_commons
# if six.PY2:
# reload(allure_commons._core)
# else:
# import importlib
# importlib.reload(allure_commons._core)
#
#
from allure_robotframework import allure_robotframework
listener = allure_robotframework(logger_path=tmp_path)
stdout_file = os.path.abspath(os.path.join(tmp_path, "..", "stdout.txt"))
output_path = os.path.abspath(os.path.join(tmp_path, ".."))
with open(stdout_file, 'w+') as stdout:
options = {"listener": listener, "outputdir": output_path, "stdout": stdout, "extension": "rst"}
options.update(kw)
run(path, **options)
def run_pybot(self, tcfile=None):
logger.debug(" ... in generic_testloader.run_pybot running [%s] ... " % tcfile)
if tcfile == None:
raise UnboundLocalError("Test case file name not defined!")
import os
from robot import run
rc = run(
tcfile,
loglevel=os.getenv("ROBOT_SYSLOG_LEVEL"),
outputdir=os.getenv("ROBOT_REPORTDIR"),
debugfile=os.getenv("ROBOT_DEBUGFILE"),
)
assert rc == 0
return rc
def test(self):
"""
Create the Robot command and execute it.
"""
suite_name, test_name = self._filename.split(':')[1].split('.')
log_stdout = output.LoggingFile(loggers=[self.log], level=logging.INFO)
log_stderr = output.LoggingFile(loggers=[self.log], level=logging.ERROR)
result = run(self.filename,
suite=suite_name,
test=test_name,
outputdir=self.outputdir,
stdout=log_stdout,
stderr=log_stderr)
if result:
self.fail('Robot execution returned a '
'non-0 exit code (%s)' % result)
def run_robot(app, exception):
# Get robot variables from environment
env_robot_variables = get_robot_variables()
env_robot_keys = [var.split(':')[0] for var in env_robot_variables]
robot_dir = app.config.sphinxcontrib_robotframework_dir
# Run the test suite:
options = {
'outputdir': robot_dir,
'variable': env_robot_variables + [
'%s:%s' % (key, value) for key, value
in app.config.sphinxcontrib_robotframework_variables.items()
if not key in env_robot_keys
]
}
if app.config.sphinxcontrib_robotframework_name:
options['name'] = app.config.sphinxcontrib_robotframework_name
result = robot.run(robot_dir, **options)
def run(self, *args):
res = None
#try:
pybot_args = "".join(args[0])
res = run(pybot_args)
print(res)
if self.auto_mode:
if res != 0:
GPIO.output(self.red_led, GPIO.HIGH)
else:
GPIO.output(self.green_led, GPIO.HIGH)
time.sleep(15)
else:
if res != 0:
GPIO.output(self.red_led, GPIO.HIGH)
else:
GPIO.output(self.green_led, GPIO.HIGH)
input("Press enter to confirm that you've seen the result, disable this message with setting auto_mode=True")
GPIO.output(self.red_led, GPIO.LOW)
GPIO.output(self.green_led, GPIO.LOW)
GPIO.cleanup()
