def main():
exit_code = 0
tender_file_path = os.path.join(PWD, "data/tender_data.json")
run_auction(tender_file_path,
auction_id="11111111111111111111111111111111")
sleep(4)
# with mock_patch('sys.exit') as exit_mock:
try:
run_cli([
'-L',
'DEBUG',
'--exitonfailure',
'-v',
'tender_file_path:{}'.format(tender_file_path),
'-v',
'auction_worker_defaults:{0}/etc/auction_worker_defaults.yaml'.
format(CWD),
'-l',
'{0}/logs/log_simple_auction'.format(CWD),
'-r',
'{0}/logs/report_simple_auction'.format(CWD),
'-d',
os.path.join(CWD, "logs"),
PWD,
])
except SystemExit, e:
exit_code = e.code
def python(*opts):
try:
run_cli(['--outputdir', OUTPUT_PYTHON,
'--include', 'pybot']
+ list(COMMON_OPTS + opts))
except SystemExit:
pass
def run(self):
for i in range(3):
time.sleep(random.randint(1, 10))
run_cli(self.cmd)
name, status = self.check_test_result_from_output(self.rpt_path)
if status == 'PASS':
break
self.status = status
def jython(*opts):
try:
run_cli([
'--outputdir', OUTPUT_JYTHON, '--pythonpath', JAR_PATH,
'--include', 'jybot'
] + list(COMMON_OPTS + opts))
except SystemExit:
pass
def jython(*opts):
try:
run_cli(['--outputdir', OUTPUT_JYTHON,
'--pythonpath', JAR_PATH,
'--include', 'jybot']
+ list(COMMON_OPTS + opts))
except SystemExit:
pass
def atest(attempt, extra_args):
""" perform a single attempt of the acceptance tests
"""
extra_args += OS_PY_ARGS.get((OS, PY), [])
stem = get_stem(attempt, extra_args)
for non_critical in NON_CRITICAL:
extra_args += ["--noncritical", "AND".join(non_critical)]
if attempt != 1:
previous = OUT / f"{get_stem(attempt - 1, extra_args)}.robot.xml"
if previous.exists():
extra_args += ["--rerunfailed", str(previous)]
out_dir = OUT / stem
args = [
"--name",
f"{OS}{PY}",
"--outputdir",
out_dir,
"--output",
OUT / f"{stem}.robot.xml",
"--log",
OUT / f"{stem}.log.html",
"--report",
OUT / f"{stem}.report.html",
"--xunitskipnoncritical",
"--xunit",
OUT / f"{stem}.xunit.xml",
"--variable",
f"OS:{OS}",
"--variable",
f"PY:{PY}",
"--randomize",
"all",
*(extra_args or []),
ATEST,
]
print("Robot Arguments\n", " ".join(["robot"] + list(map(str, args))))
os.chdir(ATEST)
if out_dir.exists():
print("trying to clean out {}".format(out_dir))
try:
shutil.rmtree(out_dir)
except Exception as err:
print("Error deleting {}, hopefully harmless: {}".format(
out_dir, err))
try:
robot.run_cli(list(map(str, args)))
return 0
except SystemExit as err:
return err.code
def run_atests(args):
if '--help' in args:
print(__doc__)
return 251
if not args or not exists(args[-1]):
args.append(join(ROOT, 'atest'))
try:
run_cli(CONFIG + args)
except SystemExit as exit:
return exit.code
def run_atests(args):
if '--help' in args:
print(__doc__)
return 251
if not args or not exists(args[-1]):
args.append(join(ROOT, 'atest'))
try:
run_cli(CONFIG + args)
except SystemExit as exit:
return exit.code
def run_cli(args):
# abstracts away this change
# https://code.google.com/p/robotframework/source/detail?r=ebc6fbb542e6
# so we can test this lib against RF 2.6 and 2.7 w/o much config overhead
import robot
try:
robot.run_cli(args)
except Exception as e:
print(e)
import robot.runner
robot.run_from_cli(args, robot.runner.__doc__)
def run_cli(args):
# abstracts away this change
# https://code.google.com/p/robotframework/source/detail?r=ebc6fbb542e6
# so we can test this lib against RF 2.6 and 2.7 w/o much config overhead
import robot
try:
robot.run_cli(args)
except Exception, e:
print e
import robot.runner
robot.run_from_cli(args, robot.runner.__doc__)
def run_tests(interpreter=None):
test_path = os.path.join('src', 'test', 'robotframework', 'acceptance')
if interpreter is None:
sys.path.extend(list(get_env()))
run_cli(['--loglevel', 'DEBUG', test_path])
else:
set_env()
if sys.platform.startswith('win'):
which_program = 'where'
else:
which_program = 'which'
which_pybot = check_output([which_program, 'pybot']).rstrip()
call([interpreter, which_pybot, '--loglevel', 'DEBUG', test_path])
def main():
tender_file_path = os.path.join(PWD, "data/tender_data.json")
auction_process = run_auction(tender_file_path)
sleep(4)
# with mock_patch('sys.exit') as exit_mock:
exit_code = 0
try:
run_cli(['-L', 'DEBUG', '--exitonfailure',
'-v', 'tender_file_path:{}'.format(tender_file_path),
'-v', 'auction_worker_defaults:{0}/etc/auction_worker_defaults.json'.format(CWD),
'-d', os.path.join(CWD, "logs"), PWD,])
except SystemExit, e:
exit_code = e.code
def run_tests(interpreter=None):
test_path = os.path.join('src', 'test', 'robotframework', 'acceptance')
if interpreter is None:
sys.path.extend(list(get_env()))
run_cli(['--loglevel', 'DEBUG', test_path])
else:
set_env()
if sys.platform.startswith('win'):
which_program = 'where'
else:
which_program = 'which'
which_pybot = check_output([which_program, 'pybot']).rstrip()
call([interpreter, which_pybot, '--loglevel', 'DEBUG', test_path])
def run_robot_task(queue, args):
exit_orig = sys.exit
ret = 0
def exit_new(r):
nonlocal ret
ret = r
sys.exit = exit_new
robot.run_cli(args)
queue.put(ret)
sys.exit = exit_orig
def pybot():
# This code hides warnings for known Sphinx-only-directives when
# executing pybot against Sphinx-documentation:
from docutils.parsers.rst.directives import register_directive
from docutils.parsers.rst.roles import register_local_role
dummy_directive = lambda *args: []
options = ('maxdepth', 'creates', 'numbered', 'hidden')
setattr(dummy_directive, 'content', True)
setattr(dummy_directive, 'options', dict([(opt, str) for opt in options]))
register_directive('toctree', dummy_directive)
register_directive('robotframework', dummy_directive)
register_local_role('ref', dummy_directive)
# Run pybot
run_cli(sys.argv[1:])
def pybot():
# This code hides warnings for known Sphinx-only-directives when
# executing pybot against Sphinx-documentation:
from docutils.parsers.rst.directives import register_directive
from docutils.parsers.rst.roles import register_local_role
dummy_directive = lambda *args: []
options = ('maxdepth', 'creates', 'numbered', 'hidden')
setattr(dummy_directive, 'content', True)
setattr(dummy_directive, 'options', dict([(opt, str) for opt in options]))
register_directive('toctree', dummy_directive)
register_directive('robotframework', dummy_directive)
register_local_role('ref', dummy_directive)
# Run pybot
run_cli(sys.argv[1:])
def pybot():
# This code hides warnings for known Sphinx-only-directives when
# executing pybot against Sphinx-documentation:
from docutils.parsers.rst.directives import register_directive
from docutils.parsers.rst.roles import register_local_role
dummy_directive = lambda *args: []
options = ("maxdepth", "creates", "numbered", "hidden")
setattr(dummy_directive, "content", True)
setattr(dummy_directive, "options", dict([(opt, str) for opt in options]))
register_directive("toctree", dummy_directive)
register_directive("robotframework", dummy_directive)
register_local_role("ref", dummy_directive)
# Run pybot
run_cli(sys.argv[1:])
def shell():
"""A standalone robotframework shell"""
import tempfile
# ceate test suite file for REPL.
source = tempfile.NamedTemporaryFile(prefix='robot_debug',
suffix='.txt',
delete=False)
source.write(b'''*** Settings ***
Library DebugLibrary
** test case **
RFDEBUG REPL
debug
''')
source.flush()
args = '-l None -x None -o None -L None -r None ' + source.name
from robot import run_cli
rc = run_cli(args.split())
source.close()
if os.path.exists(source.name):
os.unlink(source.name)
sys.exit(rc)
def shell():
"""A standalone robotframework shell"""
# ceate test suite file for REPL.
source = tempfile.NamedTemporaryFile(prefix='robot_debug',
suffix='.txt',
delete=False)
source.write(b'''*** Settings ***
Library DebugLibrary
** test case **
RFDEBUG REPL
debug
''')
source.flush()
default_no_logs = '-l None -x None -o None -L None -r None'
if len(sys.argv) > 1:
args = sys.argv[1:] + [source.name]
else:
args = default_no_logs.split() + [source.name]
rc = run_cli(args)
source.close()
if os.path.exists(source.name):
os.unlink(source.name)
sys.exit(rc)
def shell():
'''A standalone robotframework shell'''
import tempfile
# ceate test suite file for REPL.
source = tempfile.NamedTemporaryFile(prefix='robot_debug',
suffix='.txt', delete=False)
source.write('''*** Settings ***
Library DebugLibrary
** test case **
REPL
debug
''')
source.flush()
args = '-l None -x None -o None -L None ' + source.name
import robot
try:
from robot import run_cli
rc = run_cli(args.split())
except ImportError:
import robot.runner
rc = robot.run_from_cli(args.split(), robot.runner.__doc__)
source.close()
if os.path.exists(source.name):
os.unlink(source.name)
sys.exit(rc)
def runTask(self, rowid, procsCount, lock):
tasks = TasksDB(self.args.outputdir)
suite = tasks.getTask(rowid)
print(str(os.getpid()) + '|Running suite ' + suite + ' .....')
with lock:
procsCount.value += 1
if suite == 'rebot':
runArgs = ['-R','-d',self.args.outputdir,self.args.outputdir+'/*.xml']
robot.rebot_cli(runArgs, exit=False)
else:
runArgs = self.robotArgs + ['-l','NONE','-r','NONE','-s',suite,'-o',suite+'.xml',self.args.main_suite]
robot.run_cli(runArgs, exit=False)
tasks.finishTask(rowid)
tasks.printTableData()
with lock:
procsCount.value -= 1
def shell():
"""A standalone robotframework shell"""
with tempfile.NamedTemporaryFile(prefix='robot-debug-',
suffix='.txt',
delete=False) as test_file:
try:
test_file.write(TEST_SUITE)
test_file.flush()
default_no_logs = '-l None -x None -o None -L None -r None'
if len(sys.argv) > 1:
args = sys.argv[1:] + [test_file.name]
else:
args = default_no_logs.split() + [test_file.name]
rc = run_cli(args)
sys.exit(rc)
finally:
test_file.close()
# pybot will raise PermissionError on Windows NT or later
# if NamedTemporaryFile called with `delete=True`,
# deleting test file seperated will be OK.
if os.path.exists(test_file.name):
os.unlink(test_file.name)
def robot():
# Enable nbreader
if 'ipynb' not in populators.READERS:
populators.READERS['ipynb'] = NotebookReader
TEST_EXTENSIONS.add('ipynb')
RESOURCE_EXTENSIONS.add('ipynb')
return run_cli(sys.argv[1:])
def shell():
'''A standalone robotframework shell'''
import tempfile
# ceate test suite file for REPL.
source = tempfile.NamedTemporaryFile(prefix='robot_debug',
suffix='.txt',
delete=False)
source.write(b'''*** Settings ***
Library DebugLibrary
** test case **
REPL
debug
''')
source.flush()
args = '-l None -x None -o None -L None ' + source.name
import robot
try:
from robot import run_cli
rc = run_cli(args.split())
except ImportError:
import robot.runner
rc = robot.run_from_cli(args.split(), robot.runner.__doc__)
source.close()
if os.path.exists(source.name):
os.unlink(source.name)
sys.exit(rc)
def runner():
args = sys.argv[1:]
if '-d' not in args:
directory = os.path.join(os.getcwd(), 'test_output')
if not os.path.exists(directory):
os.mkdir(directory)
args += ['-d', directory]
args.append(os.path.join(os.path.dirname(__file__), 'tests_files'))
return run_cli(args)
def run(suite, env, project = "", version = "", cycle = ""):
print "running tests using settings: ", env
#rm -f ROBOT_DIR + "/output/*.*"
if (os.path.exists(OUTPUT_DIR)):
shutil.rmtree(OUTPUT_DIR)
# generate robomachine tests for this suite
subprocess.call(["python", os.path.join(SCRIPT_DIR, "generate_robomachine_tests.py"), suite])
# robot arguments
arg_list = ["--variablefile", os.path.join(SETTINGS_DIR, env +".py"),
"--pythonpath", PYTHONLIBS_DIR + ":" + RESOURCE_DIR + ":" + SETTINGS_DIR,
"--outputdir", OUTPUT_DIR,
"--exclude", "Draft",
# "--include", "RDC-647",
"--nostatusrc",
"--xunit", "xunit.xml"]
# if project name is specified test run results will be reported to JIRA using Zephyr
if project != "":
arg_list.append("--listener")
arg_list.append("realtest.zephyr.ZephyrLibrary")
arg_list.append("--metadata")
arg_list.append("Project:" + project)
if version != "":
arg_list.append("--metadata")
arg_list.append("Version:" + version)
if cycle != "":
arg_list.append("--metadata")
arg_list.append("Testcycle:" + cycle)
# specify test suite
arg_list.append(os.path.join(SUITES_DIR, suite))
# append generated suite if exists
if (os.path.isdir(GENERATED_DIR)):
arg_list.append(os.path.join(SUITES_DIR, "generated"))
# run tests
robot.run_cli(arg_list)
def execute(self):
if self.debug:
print("Environment: %s" % self.full_environment)
print("Commandline: %s" % self.commandline)
# pylint: disable=unused-variable
for key, value in self.new_environment_variables.items():
newpaths = value.split(os.pathsep)
for path in newpaths:
pythonpathsetter.add_path(path, True)
return run_cli(self.commandline[1:], exit=False) # pylint: disable=unsubscriptable-object
def atest(attempt, extra_args):
""" perform a single attempt of the acceptance tests
"""
stem = "_".join([OS, PY, str(attempt)]).replace(".", "_").lower()
out_dir = OUT / stem
args = [
"--name",
f"{OS}{PY}",
"--outputdir",
out_dir,
"--output",
OUT / f"{stem}.robot.xml",
"--log",
OUT / f"{stem}.log.html",
"--report",
OUT / f"{stem}.report.html",
"--xunit",
OUT / f"{stem}.xunit.xml",
"--variable",
f"OS:{OS}",
"--variable",
f"PY:{PY}",
*(extra_args or []),
ATEST,
]
os.chdir(ATEST)
if out_dir.exists():
print("trying to clean out {}".format(out_dir))
try:
shutil.rmtree(out_dir)
except Exception as err:
print("Error deleting {}, hopefully harmless: {}".format(
out_dir, err))
try:
robot.run_cli(list(map(str, args)))
return 0
except SystemExit as err:
return err.code
def run(self):
import robot # type: ignore
code = robot.run_cli(
[
"--outputdir=%s" % (self.dap_logs_dir, ),
"--listener=robotframework_debug_adapter.listeners.DebugListener",
self.target,
],
exit=False,
)
self.result_code = code
def run(target):
import robot
code = robot.run_cli(
[
"--outputdir=%s" % (dap_logs_dir, ),
"--listener=robotframework_debug_adapter.listeners.DebugListener",
target,
],
exit=False,
)
return code
def main():
try:
import robotframework_ls
except ImportError:
# Automatically add it to the path if __main__ is being executed.
sys.path.append(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
import robotframework_ls # @UnusedImport
from robotframework_ls.robotframework_log import (
configure_logger,
log_args_and_python,
)
from robotframework_ls.robotframework_log import get_logger
configure_logger("robot")
log = get_logger("robotframework_debug_adapter.run_robot__main__.py")
log_args_and_python(log, sys.argv)
from robotframework_ls.options import DEFAULT_TIMEOUT
args = sys.argv[1:]
assert args[0] == "--port"
port = args[1]
robot_args = args[2:]
s = connect(int(port))
processor = _DAPCommandProcessor(s)
processor.start_communication_threads()
if not processor.configuration_done.wait(DEFAULT_TIMEOUT):
sys.stderr.write(
"Process not configured for launch in the available timeout.\n")
sys.exit(1)
try:
from robot import run_cli
exitcode = run_cli(robot_args, exit=False)
finally:
processor.terminate()
if processor.terminated.wait(2):
log.debug("Processed dap terminate event in robot.")
sys.exit(exitcode)
def atest(attempt=0):
""" run the acceptance tests once
"""
# pylint: disable=broad-except
stem = "_".join([OS, PY, str(attempt)]).replace(".", "_").lower()
out_dir = OUT / stem
args = [
"--name",
f"{OS}{PY}",
"--outputdir",
out_dir,
"--output",
OUT / f"{stem}.robot.xml",
"--log",
OUT / f"{stem}.log.html",
"--report",
OUT / f"{stem}.report.html",
"--xunit",
OUT / f"{stem}.xunit.xml",
"--variable",
f"OS:{OS}",
"--variable",
f"PY:{PY}",
"--noncritical",
"ospy:windows38",
"--xunitskipnoncritical",
*sys.argv[1:],
ATEST,
]
os.chdir(ATEST)
if out_dir.exists():
print("trying to clean out {}".format(out_dir))
try:
shutil.rmtree(out_dir)
except Exception as err:
print("Error deleting {}, hopefully harmless: {}".format(
out_dir, err))
return robot.run_cli(list(map(str, args)), exit=False)
def shell():
"""A standalone robotframework shell"""
with tempfile.NamedTemporaryFile(prefix='robot-debug-',
suffix='.txt',
delete=True) as test_file:
test_file.write(b'''*** Settings ***
Library DebugLibrary
** test case **
RFDEBUG REPL
debug
''')
test_file.flush()
default_no_logs = '-l None -x None -o None -L None -r None'
if len(sys.argv) > 1:
args = sys.argv[1:] + [test_file.name]
else:
args = default_no_logs.split() + [test_file.name]
rc = run_cli(args)
sys.exit(rc)
def run(self, args, opts):
"""Sub command 'debug' runner"""
source = tempfile.NamedTemporaryFile(prefix='robot_debug',
suffix='.txt', delete=False)
source.write('''*** Settings ***
Library robotx.lib.DebugLibrary.Debug
** Test Cases **
A Debug Case
debug
''')
source.flush()
args = '-L TRACE ' + source.name
try:
from robot import run_cli
rc = run_cli(args.split())
except ImportError:
import robot.runner
rc = robot.run_from_cli(args.split(), robot.runner.__doc__)
source.close()
if os.path.exists(source.name):
os.unlink(source.name)
sys.exit(rc)
def run(self, args, opts):
"""Sub command 'debug' runner"""
source = tempfile.NamedTemporaryFile(prefix='robot_debug',
suffix='.txt',
delete=False)
source.write('''*** Settings ***
Library robotx.lib.DebugLibrary.Debug
** Test Cases **
A Debug Case
debug
''')
source.flush()
args = '-L TRACE ' + source.name
try:
from robot import run_cli
rc = run_cli(args.split())
except ImportError:
import robot.runner
rc = robot.run_from_cli(args.split(), robot.runner.__doc__)
source.close()
if os.path.exists(source.name):
os.unlink(source.name)
sys.exit(rc)
def shell():
'''A standalone robotframework shell'''
import tempfile
# ceate test suite file for REPL.
source = tempfile.NamedTemporaryFile(prefix='robot_debug', suffix='.txt')
source.write('''*** Settings ***
Library DebugLibrary
** test case **
REPL
debug
''')
source.flush()
import robot
import robot.runner
args = '-l None -x None -o None -L None ' + source.name
robot_version = robot.version.get_version()
if robot_version > '2.7':
rc = robot.run_cli(args.split())
else:
rc = robot.run_from_cli(args.split(), robot.runner.__doc__)
sys.exit(rc)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
from os.path import abspath, dirname, join as path_join
from robot import run_cli
if __name__ == '__main__':
curdir = abspath(dirname(__file__))
sys.path.insert(1, abspath(path_join(curdir, '..', '..', 'src')))
from ImageHorizonLibrary.utils import *
if is_windows():
tag = 'windows'
elif is_mac():
tag = 'mac'
elif is_linux():
tag = 'linux'
run_cli(sys.argv[1:] + ['--include', tag, '.'])
def test_run_cli_optionally_returns_rc(self):
rc = run_cli([self.data], exit=False)
assert_equal(rc, 1)
def pybot():
run_cli(sys.argv[1:])
def main(cli_args):
extend_python_path()
cli_args.extend(DEFAULT_ARGS.split())
return run_cli(cli_args)
def robot_debug():
run_cli(
["--listener", "plone.app.robotframework.RobotListener", "-v", "SELENIUM_RUN_ON_FAILURE:Debug"] + sys.argv[1:]
)
def robot_debug():
run_cli(['--listener', 'plone.app.robotframework.RobotListener',
'-v', 'SELENIUM_RUN_ON_FAILURE:Debug']
+ sys.argv[1:])
def robot():
run_cli(['--listener', 'plone.app.robotframework.RobotListener']
+ sys.argv[1:])
def test_run_cli_optionally_returns_rc(self):
rc = run_cli(['-d', TEMP, self.data], exit=False)
assert_equal(rc, 1)
def robot_debug():
run_cli([
'--listener', 'plone.app.robotframework.RobotListener', '-v',
'SELENIUM_RUN_ON_FAILURE:Debug'
] + sys.argv[1:])
def main(cli_args):
extend_python_path()
cli_args.extend(DEFAULT_ARGS.split())
return run_cli(cli_args)
# Copyright 2008-2012 Nokia Siemens Networks Oyj
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import sys
# Allows running as a script. __name__ check needed with multiprocessing:
# http://code.google.com/p/robotframework/issues/detail?id=1137
if 'robot' not in sys.modules and __name__ == '__main__':
import pythonpathsetter
from robot import run_cli
from robot.output import LOGGER
LOGGER.warn("'robot/runner.py' entry point is deprecated and will be removed "
"in Robot Framework 2.8. Use new 'robot/run.py' instead.")
if __name__ == '__main__':
run_cli(sys.argv[1:])
def robot():
run_cli(['--listener', 'plone.app.robotframework.RobotListener'] +
sys.argv[1:])
try:
from robot import run_cli
except:
sys.stderr.write("ERROR: Robot Framework is not installed\n")
exit(1)
from robot.api import logger
TESTHOME = os.path.dirname(argv[0])
testsuites_path = os.path.join(TESTHOME, "implementation/testsuites/")
# If no argument given, run the whole testsuite
if len(argv) == 1:
logger.warn("Running the whole testsuite")
argv.append(testsuites_path)
run_cli(argv[1:])
exit(0)
# If "-s" or "--suite" given as arguments, exit
if set.intersection(set(["-s", "--suite"]), set(argv)):
logger.warn("-s/--suite command line argument is disabled." \
" Please give the direct path to the testsuite")
exit(1)
# Determine run_cli arguments
args = []
isopt = False
suitename = ""
for i in xrange(1, len(argv)):
arg = argv[i]
def robot():
run_cli(["--listener", "plone.app.robotframework.RobotListener"] + sys.argv[1:])
def main():
TESTS = {}
for entry_point in iter_entry_points('openprocurement.auction.robottests'):
suite = entry_point.load()
TESTS.update(suite())
parser = argparse.ArgumentParser('Auction test runner')
parser.add_argument('suite',
choices=TESTS.keys(),
default='simple',
nargs='?',
help='test_suite')
parser.add_argument('--browser',
dest='browser',
choices=['firefox', 'chrome', 'phantomjs'],
default='chrome',
nargs='?',
help='supported browsers')
parser.add_argument('--ip',
dest='ip',
nargs='?',
help='ip of the remote server where tests will be run')
parser.add_argument('--port',
dest='port',
nargs='?',
help='port of the remote server where tests will be '
'run')
args = parser.parse_args()
if args.port and (not args.ip):
parser.error('The --port argument requires the --ip')
if args.ip and (args.browser != 'chrome'):
parser.error('Only chrome is allowed for remote test running')
port = getattr(args, 'port', '4444')
remote_url = 'None' if not args.ip else 'http://{}:{}/wd/hub'\
.format(args.ip, port)
desired_capabilities = DesiredCapabilities.CHROME if \
args.browser == 'chrome' else 'None'
test = TESTS[args.suite]
test['runner'](test['worker_cmd'], test['tender_file_path'],
test['auction_id'])
auction_worker_defaults = test['auction_worker_defaults']
cli_args = [
'-L',
'TRACE',
'--exitonfailure',
'-v', 'tender_file_path:{}'.format(test['tender_file_path']),
'-v', auction_worker_defaults.format(CWD),
'-v', 'auction_id:{}'.format(test['auction_id']),
'-v', 'BROWSER:{}'.format(args.browser),
'-v', 'remote_url:{}'.format(remote_url),
'-v', 'desired_capabilities:{}'.format(desired_capabilities),
'-l', '{0}/logs/log_{1}'.format(CWD, args.suite),
'-r', '{0}/logs/report_{1}'.format(CWD, args.suite),
'-P', test['suite'],
'-d', os.path.join(CWD, "logs"),
test['suite']
]
sleep(4)
try:
run_cli(cli_args)
except SystemExit, e:
exit_code = e.code
