def test_double_stop():
vd = Display().start().stop()
assert vd.return_code == 0
assert not vd.is_alive()
vd.stop()
assert vd.return_code == 0
assert not vd.is_alive()
def test_stop_terminated():
vd = Display().start()
assert vd.is_alive()
vd._obj._subproc.terminate()
sleep(0.2)
assert not vd.is_alive()
vd.stop()
assert vd.return_code == 0
assert not vd.is_alive()
def test_nest():
vd = Display().start()
assert vd.is_alive()
nd = Display(visible=True).start().stop()
assert nd.return_code == 0
vd.stop()
assert not vd.is_alive()
def test_disp():
vd = Display().start()
assert vd.is_alive()
# d = Display(visible=True).start().sleep(2).stop()
# .assertEquals(d.return_code, 0)
d = Display(visible=False).start().stop()
assert d.return_code == 0
vd.stop()
assert not vd.is_alive()
def test_virt():
vd = Display()
assert vd.return_code is None
assert not vd.is_alive()
vd.start()
assert vd.return_code is None
assert vd.is_alive()
vd.stop()
assert vd.return_code == 0
assert not vd.is_alive()
vd = Display().start().stop()
assert vd.return_code == 0
assert not vd.is_alive()
def test_extra_args():
# Unrecognized option
d = Display(extra_args=["willcrash"])
with pytest.raises(XStartError):
d.start()
with Display():
# -c turns off key-click
with Display(visible=True, extra_args=["-c"]) as d:
assert d.is_alive()
assert not d.is_alive()
with XephyrDisplay(extra_args=["-c"]) as d:
assert d.is_alive()
assert not d.is_alive()
def main(i, backend):
# TODO: test all backends
d = Display(backend=backend).start()
print("my index:%s backend:%s disp:%s" % (i, backend, d.new_display_var))
ok = d.is_alive()
d.stop()
assert ok
def new_driver_wrapper(startup_url=None):
logger = logging.getLogger(__name__)
browser_config = BrowserConfig()
display = None
if browser_config.getbool('use_headless_browser'
) and not browser_config.getbool('use_remote'):
display = Display(visible=0, size=(1280, 1024))
display.start()
display_pid = display.pid
def process_exists(pid):
try:
os.kill(pid, 0)
except OSError:
return False
else:
return True
polling.poll(
lambda: display.is_alive(),
timeout=60,
exception_message='Display was not alive; process was: {}'.format(
display_pid),
ontimeout=(
lambda: logger.critical('Display process {} exists: {}'.format(
display_pid, process_exists(display_pid))), ))
polling.poll(
lambda: display.is_started,
timeout=60,
exception_message=
'Display was alive but not started; process was: {}'.format(
display_pid))
# TODO: Is there a better condition we can check here?
time.sleep(1.5)
driver = new_driver()
logging.getLogger(__name__).info('Browser successfully launched')
action_callbacks = []
# Fail if there are errors in the console
if TestrunConfig().getbool('fail_on_console_errors'):
action_callbacks.append(_log_fail_callback)
driver_wrapper = CoyoteDriver(
driver=driver,
display=display,
options={
'timeout': 40,
'page_load_timeout': 45,
'ignore_page_load_timeouts':
True, # Prevent page timeouts from breaking out tests
'action_callbacks': action_callbacks
})
driver.set_window_size(*(1280, 1024))
return driver_wrapper
def _start_virtual_display(width, height):
from pyvirtualdisplay import Display
d = Display(visible=0, size=(width, height))
d.start()
if d.stderr or not d.is_alive():
raise Exception(
'Could not open headless Display with width({}) and height ({}). StdErr: {}'
''.format(width, height, d.stderr))
return d
def new_driver_wrapper(startup_url=None):
logger = logging.getLogger(__name__)
browser_config = BrowserConfig()
display = None
if browser_config.getbool('use_headless_browser') and not browser_config.getbool('use_remote'):
display = Display(visible=0, size=(1280, 1024))
display.start()
display_pid = display.pid
def process_exists(pid):
try:
os.kill(pid, 0)
except OSError:
return False
else:
return True
polling.poll(
lambda: display.is_alive(),
timeout=60,
exception_message='Display was not alive; process was: {}'.format(display_pid),
ontimeout=(
lambda: logger.critical('Display process {} exists: {}'.format(
display_pid,
process_exists(display_pid))
),
)
)
polling.poll(
lambda: display.is_started,
timeout=60,
exception_message='Display was alive but not started; process was: {}'.format(display_pid)
)
# TODO: Is there a better condition we can check here?
time.sleep(1.5)
driver = new_driver()
logging.getLogger(__name__).info('Browser successfully launched')
action_callbacks = []
# Fail if there are errors in the console
if TestrunConfig().getbool('fail_on_console_errors'):
action_callbacks.append(_log_fail_callback)
driver_wrapper = CoyoteDriver(driver=driver, display=display, options={
'timeout': 40,
'page_load_timeout': 45,
'ignore_page_load_timeouts': True, # Prevent page timeouts from breaking out tests
'action_callbacks': action_callbacks
})
driver.set_window_size(*(1280, 1024))
return driver_wrapper
def main(i, backend, retries):
retries = int(retries)
kwargs = dict()
if backend == "xvnc":
kwargs["rfbport"] = 42000 + int(i)
d = Display(backend=backend, retries=retries, **kwargs).start()
print("my index:%s backend:%s disp:%s retries:%s" %
(i, backend, d.new_display_var, d._obj._retries_current))
ok = d.is_alive()
d.stop()
assert ok
def main(i, backend, retries):
retries = int(retries)
kwargs = dict()
if backend == "xvnc":
kwargs["rfbport"] = 42000 + 100 * worker() + int(i)
# print("$DISPLAY=%s" % (os.environ.get("DISPLAY")))
d = Display(backend=backend, retries=retries, **kwargs).start()
print("my index:%s backend:%s disp:%s retries:%s" % (
i,
backend,
d.new_display_var,
d._obj._retries_current,
))
ok = d.is_alive()
d.stop()
assert ok
class SeleniumExecutor(ScenarioExecutor, WidgetProvider, FileLister):
"""
Selenium executor
:type virtual_display: Display
"""
SELENIUM_DOWNLOAD_LINK = "http://selenium-release.storage.googleapis.com/{version}/" \
"selenium-server-standalone-{version}.0.jar"
SELENIUM_VERSION = "2.46"
JUNIT_DOWNLOAD_LINK = "http://search.maven.org/remotecontent?filepath=junit/junit/{version}/junit-{version}.jar"
JUNIT_VERSION = "4.12"
JUNIT_MIRRORS_SOURCE = "http://search.maven.org/solrsearch/select?q=g%3A%22junit%22%20AND%20a%3A%22junit%22%20" \
"AND%20v%3A%22{version}%22&rows=20&wt=json".format(version=JUNIT_VERSION)
HAMCREST_DOWNLOAD_LINK = "https://hamcrest.googlecode.com/files/hamcrest-core-1.3.jar"
SUPPORTED_TYPES = [".py", ".jar", ".java"]
def __init__(self):
super(SeleniumExecutor, self).__init__()
self.virtual_display = None
self.start_time = None
self.end_time = None
self.runner = None
self.widget = None
self.reader = None
self.kpi_file = None
self.err_jtl = None
self.runner_working_dir = None
self.scenario = None
def prepare(self):
"""
1) Locate script or folder
2) detect script type
3) create runner instance, prepare runner
"""
self.scenario = self.get_scenario()
self._verify_script()
self.kpi_file = self.engine.create_artifact("selenium_tests_report", ".csv")
self.err_jtl = self.engine.create_artifact("selenium_tests_err", ".xml")
script_type = self.detect_script_type(self.scenario.get(Scenario.SCRIPT))
if script_type == ".py":
self.runner = NoseTester
runner_config = self.settings.get("selenium-tools").get("nose")
elif script_type == ".jar" or script_type == ".java":
self.runner = JunitTester
runner_config = self.settings.get("selenium-tools").get("junit")
else:
raise ValueError("Unsupported script type: %s" % script_type)
runner_config["script-type"] = script_type
self.runner_working_dir = self.engine.create_artifact(runner_config.get("working-dir", "classes"), "")
runner_config["working-dir"] = self.runner_working_dir
runner_config.get("artifacts-dir", self.engine.artifacts_dir)
runner_config.get("working-dir", self.runner_working_dir)
runner_config.get("report-file", self.kpi_file)
runner_config.get("err-file", self.err_jtl)
runner_config.get("stdout", self.engine.create_artifact("junit", ".out"))
runner_config.get("stderr", self.engine.create_artifact("junit", ".err"))
self._cp_resource_files(self.runner_working_dir)
self.runner = self.runner(runner_config, self.scenario, self.log)
self.runner.prepare()
self.reader = JTLReader(self.kpi_file, self.log, self.err_jtl)
if isinstance(self.engine.aggregator, ConsolidatingAggregator):
self.engine.aggregator.add_underling(self.reader)
display_conf = self.settings.get("virtual-display")
if display_conf:
width = display_conf.get("width", 1024)
height = display_conf.get("height", 768)
self.virtual_display = Display(size=(width, height))
def _verify_script(self):
if not self.scenario.get("script"):
if self.scenario.get("requests"):
self.scenario["script"] = self.__tests_from_requests()
else:
raise RuntimeError("Nothing to test, no requests were provided in scenario")
def _cp_resource_files(self, runner_working_dir):
"""
:return:
"""
script = self.scenario.get("script")
if Scenario.SCRIPT in self.scenario:
if os.path.isdir(script):
shutil.copytree(script, runner_working_dir)
else:
os.makedirs(runner_working_dir)
shutil.copy2(script, runner_working_dir)
def detect_script_type(self, script_path):
"""
checks if script is java or python
if it's folder or single script
:return:
"""
if not isinstance(script_path, string_types) and not isinstance(script_path, text_type):
raise RuntimeError("Nothing to test, no files were provided in scenario")
test_files = []
for dir_entry in os.walk(script_path):
if dir_entry[2]:
for test_file in dir_entry[2]:
if os.path.splitext(test_file)[1].lower() in SeleniumExecutor.SUPPORTED_TYPES:
test_files.append(test_file)
if os.path.isdir(script_path):
file_ext = os.path.splitext(test_files[0])[1].lower()
else:
file_ext = os.path.splitext(script_path)[1]
if file_ext not in SeleniumExecutor.SUPPORTED_TYPES:
raise RuntimeError("Supported tests types %s was not found" % SeleniumExecutor.SUPPORTED_TYPES)
return file_ext
def startup(self):
"""
Start runner
:return:
"""
self.start_time = time.time()
if self.virtual_display:
msg = "Starting virtual display[%s]: %s"
self.log.info(msg, self.virtual_display.size, self.virtual_display.new_display_var)
self.virtual_display.start()
self.runner.run_tests()
def check(self):
"""
check if test completed
:return:
"""
if self.widget:
self.widget.update()
if self.virtual_display and not self.virtual_display.is_alive():
self.log.info("Virtual display out: %s", self.virtual_display.stdout)
self.log.warning("Virtual display err: %s", self.virtual_display.stderr)
raise RuntimeError("Virtual display failed: %s" % self.virtual_display.return_code)
return self.runner.is_finished()
def shutdown(self):
"""
shutdown test_runner
:return:
"""
try:
self.runner.shutdown()
finally:
if self.virtual_display and self.virtual_display.is_alive():
self.virtual_display.stop()
if self.start_time:
self.end_time = time.time()
self.log.debug("Selenium tests ran for %s seconds", self.end_time - self.start_time)
def post_process(self):
if self.reader and not self.reader.buffer:
raise RuntimeWarning("Empty results, most likely Selenium failed")
def get_widget(self):
if not self.widget:
self.widget = SeleniumWidget(self.scenario.get("script"), self.runner.settings.get("stdout"))
return self.widget
def resource_files(self):
if not self.scenario:
self.scenario = self.get_scenario()
if "script" not in self.scenario:
return []
script = self.scenario.get("script")
script_type = self.detect_script_type(script)
if script_type == ".py":
runner_config = self.settings.get("selenium-tools").get("nose")
elif script_type == ".jar" or script_type == ".java":
runner_config = self.settings.get("selenium-tools").get("junit")
else:
raise ValueError("Unsupported script type: %s" % script_type)
if self.runner_working_dir is None:
self.runner_working_dir = self.engine.create_artifact(runner_config.get("working-dir", "classes"), "")
self._cp_resource_files(self.runner_working_dir)
return [os.path.basename(self.runner_working_dir)]
def __tests_from_requests(self):
filename = self.engine.create_artifact("test_requests", ".py")
nose_test = SeleniumScriptBuilder(self.scenario, self.log)
nose_test.scenario = self.scenario
nose_test.gen_test_case()
nose_test.save(filename)
return filename
class SeleniumExecutor(ScenarioExecutor, WidgetProvider, FileLister):
"""
Selenium executor
:type virtual_display: Display
"""
SELENIUM_DOWNLOAD_LINK = "http://selenium-release.storage.googleapis.com/{version}/" \
"selenium-server-standalone-{version}.0.jar"
SELENIUM_VERSION = "2.46"
JUNIT_DOWNLOAD_LINK = "http://search.maven.org/remotecontent?filepath=junit/junit/{version}/junit-{version}.jar"
JUNIT_VERSION = "4.12"
JUNIT_MIRRORS_SOURCE = "http://search.maven.org/solrsearch/select?q=g%3A%22junit%22%20AND%20a%3A%22junit%22%20" \
"AND%20v%3A%22{version}%22&rows=20&wt=json".format(version=JUNIT_VERSION)
HAMCREST_DOWNLOAD_LINK = "https://hamcrest.googlecode.com/files/hamcrest-core-1.3.jar"
SUPPORTED_TYPES = [".py", ".jar", ".java"]
def __init__(self):
super(SeleniumExecutor, self).__init__()
self.virtual_display = None
self.start_time = None
self.end_time = None
self.runner = None
self.widget = None
self.reader = None
self.kpi_file = None
self.err_jtl = None
self.runner_working_dir = None
self.scenario = None
def prepare(self):
"""
1) Locate script or folder
2) detect script type
3) create runner instance, prepare runner
"""
self.scenario = self.get_scenario()
self._verify_script()
self.kpi_file = self.engine.create_artifact("selenium_tests_report",
".csv")
self.err_jtl = self.engine.create_artifact("selenium_tests_err",
".xml")
script_type = self.detect_script_type(self.scenario.get("script"))
if script_type == ".py":
self.runner = NoseTester
runner_config = self.settings.get("selenium-tools").get("nose")
elif script_type == ".jar" or script_type == ".java":
self.runner = JunitTester
runner_config = self.settings.get("selenium-tools").get("junit")
else:
raise ValueError("Unsupported script type: %s" % script_type)
runner_config["script-type"] = script_type
self.runner_working_dir = self.engine.create_artifact(
runner_config.get("working-dir", "classes"), "")
runner_config["working-dir"] = self.runner_working_dir
runner_config.get("artifacts-dir", self.engine.artifacts_dir)
runner_config.get("working-dir", self.runner_working_dir)
runner_config.get("report-file", self.kpi_file)
runner_config.get("err-file", self.err_jtl)
runner_config.get("stdout",
self.engine.create_artifact("junit", ".out"))
runner_config.get("stderr",
self.engine.create_artifact("junit", ".err"))
self._cp_resource_files(self.runner_working_dir)
self.runner = self.runner(runner_config, self.scenario, self.log)
self.runner.prepare()
self.reader = JTLReader(self.kpi_file, self.log, self.err_jtl)
if isinstance(self.engine.aggregator, ConsolidatingAggregator):
self.engine.aggregator.add_underling(self.reader)
display_conf = self.settings.get("virtual-display")
if display_conf:
width = display_conf.get("width", 1024)
height = display_conf.get("height", 768)
self.virtual_display = Display(size=(width, height))
def _verify_script(self):
if not self.scenario.get("script"):
if self.scenario.get("requests"):
self.scenario["script"] = self.__tests_from_requests()
else:
raise RuntimeError(
"Nothing to test, no requests were provided in scenario")
def _cp_resource_files(self, runner_working_dir):
"""
:return:
"""
script = self.scenario.get("script")
if Scenario.SCRIPT in self.scenario:
if os.path.isdir(script):
shutil.copytree(script, runner_working_dir)
else:
os.makedirs(runner_working_dir)
shutil.copy2(script, runner_working_dir)
def detect_script_type(self, script_path):
"""
checks if script is java or python
if it's folder or single script
:return:
"""
if not isinstance(script_path, string_types) and not isinstance(
script_path, text_type):
raise RuntimeError(
"Nothing to test, no files were provided in scenario")
test_files = []
for dir_entry in os.walk(script_path):
if dir_entry[2]:
for test_file in dir_entry[2]:
if os.path.splitext(test_file)[1].lower(
) in SeleniumExecutor.SUPPORTED_TYPES:
test_files.append(test_file)
if os.path.isdir(script_path):
file_ext = os.path.splitext(test_files[0])[1].lower()
else:
file_ext = os.path.splitext(script_path)[1]
if file_ext not in SeleniumExecutor.SUPPORTED_TYPES:
raise RuntimeError("Supported tests types %s was not found" %
SeleniumExecutor.SUPPORTED_TYPES)
return file_ext
def startup(self):
"""
Start runner
:return:
"""
self.start_time = time.time()
if self.virtual_display:
msg = "Starting virtual display[%s]: %s"
self.log.info(msg, self.virtual_display.size,
self.virtual_display.new_display_var)
self.virtual_display.start()
self.runner.run_tests()
def check(self):
"""
check if test completed
:return:
"""
if self.widget:
self.widget.update()
if self.virtual_display and not self.virtual_display.is_alive():
self.log.info("Virtual display out: %s",
self.virtual_display.stdout)
self.log.warning("Virtual display err: %s",
self.virtual_display.stderr)
raise RuntimeError("Virtual display failed: %s" %
self.virtual_display.return_code)
return self.runner.is_finished()
def shutdown(self):
"""
shutdown test_runner
:return:
"""
try:
self.runner.shutdown()
finally:
if self.virtual_display and self.virtual_display.is_alive():
self.virtual_display.stop()
if self.start_time:
self.end_time = time.time()
self.log.debug("Selenium tests ran for %s seconds",
self.end_time - self.start_time)
def post_process(self):
if self.reader and not self.reader.buffer:
raise RuntimeWarning("Empty results, most likely Selenium failed")
def get_widget(self):
if not self.widget:
self.widget = SeleniumWidget(self.scenario.get("script"),
self.runner.settings.get("stdout"))
return self.widget
def resource_files(self):
if not self.scenario:
self.scenario = self.get_scenario()
if "script" not in self.scenario:
return []
script = self.scenario.get("script")
script_type = self.detect_script_type(script)
if script_type == ".py":
runner_config = self.settings.get("selenium-tools").get("nose")
elif script_type == ".jar" or script_type == ".java":
runner_config = self.settings.get("selenium-tools").get("junit")
else:
raise ValueError("Unsupported script type: %s" % script_type)
if self.runner_working_dir is None:
self.runner_working_dir = self.engine.create_artifact(
runner_config.get("working-dir", "classes"), "")
self._cp_resource_files(self.runner_working_dir)
return [os.path.basename(self.runner_working_dir)]
def __tests_from_requests(self):
filename = self.engine.create_artifact("test_requests", ".py")
nose_test = SeleniumScriptBuilder(self.scenario, self.log)
nose_test.scenario = self.scenario
nose_test.gen_test_case()
nose_test.save(filename)
return filename
def test_random():
r = Randomizer()
vd = Display(randomizer=r).start().stop()
assert vd.return_code == 0
# assert r.min <= vd.display <= r.min + r.delta # can be auto nr
assert not vd.is_alive()
