def tearDown(self):
self.driver.quit()
if _CI:
sauce_client = SauceClient(_SAUCE_USER, _SAUCE_KEY)
status = (sys.exc_info() == (None, None, None))
sauce_client.jobs.update_job(job_id=self.driver.session_id, build=_TUNNEL_ID,
passed=status)
def tearDown(self):
"""Figure out if this test case was successful (based on
http://stackoverflow.com/questions/4414234). In case of a remote GUI
test, saucelabs.com is updated (which otherwise doesn't know if the
whole test case was a success).
"""
result = self.defaultTestResult() # these 2 methods have no side effects
self._feedErrorsToResult(result, self._outcome.errors)
error = self.list2reason(result.errors)
failure = self.list2reason(result.failures)
ok = not error and not failure
if gui_tests_enabled():
if settings.GUI_TESTS_REMOTE:
# Let saucelabs.com know about the outcome of this test
id = self.selenium.session_id
logger.info(f'Link to remote Selenium GUI test job: https://saucelabs.com/jobs/{id}')
from sauceclient import SauceClient
username = os.environ["SAUCE_USERNAME"]
access_key = os.environ["SAUCE_ACCESS_KEY"]
sauce_client = SauceClient(username, access_key)
sauce_client.jobs.update_job(self.selenium.session_id, passed=ok)
self.selenium.quit()
super().tearDown()
def setUp(self):
desired_caps = {}
desired_caps['platform'] = self.PLATFORM
desired_caps['browserName'] = self.BROWSER
# desired_caps = {'browserName': "firefox"}
# desired_caps['platform'] = "Windows 7"
desired_caps['version'] = "44.0"
sauce_string = self.SAUCE_USERNAME + ':' + self.SAUCE_KEY
if self.WHERE == 'remote':
# print "remote"
self.driver = webdriver.Remote('http://' + sauce_string + '@ondemand.saucelabs.com:80/wd/hub', desired_caps)
from sauceclient import SauceClient
self.sauce_client = SauceClient(self.SAUCE_USERNAME, self.SAUCE_KEY)
else:
# print "local"
self.driver = webdriver.Firefox()
self.driver.implicitly_wait(30)
self.base_url = "http://devel7.dbc.dk/"
self.verificationErrors = []
self.accept_next_alert = True
self.driver.maximize_window()
sessionID = self.driver.session_id
sessionName = 'test_sovs'
print ("SauceOnDemandSessionID=" + sessionID + " job-name=" + sessionName)
def teardown_func():
global driver
driver.quit()
sauce_client = SauceClient(username, access_key)
status = sys.exc_info() == (None, None, None)
sauce_client.jobs.update_job(driver.session_id, passed=status)
print "SauceOnDemandSessionID=%s job-name=%s" % (driver.session_id, "abc")
def tearDown(self):
"""Figure out if this test case was successful (based on
http://stackoverflow.com/questions/4414234). In case of a remote GUI
test, saucelabs.com is updated (which otherwise doesn't know if the
whole test case was a success).
"""
if hasattr(self, '_outcome'): # Python 3.4+
result = self.defaultTestResult(
) # these 2 methods have no side effects
self._feedErrorsToResult(result, self._outcome.errors)
else: # Python 3.2 - 3.3 or 2.7
result = getattr(self, '_outcomeForDoCleanups',
self._resultForDoCleanups)
error = self.list2reason(result.errors)
failure = self.list2reason(result.failures)
ok = not error and not failure
if settings.GUI_TESTS_ENABLED:
if settings.GUI_TESTS_REMOTE:
# Let saucelabs.com know about the outcome of this test
id = self.selenium.session_id
logger.info(
'Link to remote Selenium GUI test job: https://saucelabs.com/jobs/{}'
.format(id))
from sauceclient import SauceClient
username = os.environ["SAUCE_USERNAME"]
access_key = os.environ["SAUCE_ACCESS_KEY"]
sauce_client = SauceClient(username, access_key)
sauce_client.jobs.update_job(self.selenium.session_id,
passed=ok)
self.selenium.quit()
super(BasicUITest, self).tearDown()
def after_scenario(context, scenario):
if hasattr(context, 'driver'):
context.driver.quit()
sauce_client = SauceClient(username, access_key)
test_status = scenario.status == 'passed'
sauce_client.jobs.update_job(context.driver.session_id,
passed=test_status)
def update_saucelabs_testresult(session_id, test_status, sauce_username,
sauce_access_key):
sauce_client = SauceClient(sauce_username, sauce_access_key)
# this belongs in your test logic
sauce_client.jobs.update_job(session_id, passed=test_status)
def report_pass_fail(self):
sauce_client = SauceClient(user, key)
sauce_client.jobs.update_job(self.driver.session_id,
passed=self.success,
name=self.name,
build_num=buildnum)
def after_feature(context, scenario):
# print("scenario status" + scenario.status)
# if scenario.status == "failed":
# if not os.path.exists("failed_scenarios_screenshots"):
# os.makedirs("failed_scenarios_screenshots")
# os.chdir("failed_scenarios_screenshots")
# context.browser.save_screenshot(scenario.name + "_failed.png")
# context.browser.quit()
print("Link to your job: https://saucelabs.com/jobs/%s" %
context.browser.session_id)
if hasattr(context,'browser'):
sauce_client = SauceClient("sourabh94", "e4be7c8c-f774-4534-b8e6-0be51798cc77")
test_status = scenario.status == 'passed'
sauce_client.jobs.update_job(context.browser.session_id, passed=test_status)
print("scenario status" + scenario.status)
if scenario.status == "failed":
if not os.path.exists("failed_scenarios_screenshots"):
os.makedirs("failed_scenarios_screenshots")
os.chdir("failed_scenarios_screenshots")
context.browser.save_screenshot(scenario.name + "_failed.png")
context.browser.quit()
def after_scenario(context, scenario):
print("\nAfter Feature")
def tearDown(self):
print(("Link to your job: https://saucelabs.com/jobs/%s" %
self.driver.session_id))
job_passed = sys.exc_info() == (None, None, None)
sc = SauceClient(self.username, self.access_key)
sc.jobs.update_job(self.driver.session_id, passed=job_passed)
self.driver.quit()
self.connect.shutdown_connect()
def tearDown(self):
print("testing complete;closing connection")
id = self.driver.session_id
print("Link to job: https://saucelabs.com/jobs/%s" % (id))
print("Errors?", self.message)
sauce_client = SauceClient(self.SauceLogin, self.SauceAccessKey)
sauce_client.jobs.update_job(self.driver.session_id, passed=self.status)
self.driver.quit()
def init_driver_support(cls):
"""Initialise the basic config (and sauce client if requested).
"""
cls.config = Config.instance()
if cls.config['use_sauce']:
if not hasattr(cls, 'sauce'):
cls.sauce = SauceClient(cls.config['sauce_username'],
cls.config['sauce_access_key'])
def tearDown(self):
self.driver.quit()
sauce_client = SauceClient(BaseTest.username, BaseTest.access_key)
status = (sys.exc_info() == (None, None, None))
sauce_client.jobs.update_job(self.driver.session_id, passed=status)
test_name = "%s_%s" % (type(self).__name__, self.__name__)
with (open(test_name + '.testlog', 'w')) as outfile:
outfile.write("SauceOnDemandSessionID=%s job-name=%s\n" %
(self.driver.session_id, test_name))
def tearDown(self):
self.driver.quit()
session_id = self.driver.session_id
job_name = self.id()
sauce_client = SauceClient(username, access_key)
status = (sys.exc_info() == (None, None, None))
sauce_client.jobs.update_job(session_id, passed=status)
output = "SauceOnDemandSessionID=%s job-name=%s" % (session_id,
job_name)
log_to_file(output)
def tearDown(self):
if 'sauce' in self.provider.lower():
sauce = SauceClient(self.SAUCE_USERNAME, self.SAUCE_ACCESS)
self.resultLink = "https://saucelabs.com/beta/tests/%s" % self.driver.session_id
try:
if sys.exc_info() == (None, None, None):
sauce.jobs.update_job(self.driver.session_id, passed=True, name=self._testMethodName)
else:
sauce.jobs.update_job(self.driver.session_id, passed=False, name=self._testMethodName)
except:
pass
def setUpClass(cls):
super(test_remote_browser_base, cls).setUpClass()
if not cls.GENERATING_MODE:
cls.sauce = SauceClient(USERNAME, ACCESS_KEY)
cls.sauce_url = 'http://%s:%[email protected]:80/wd/hub' % (
USERNAME, ACCESS_KEY)
cls.browser = webdriver.Remote(
desired_capabilities=cls.desired_capabilities,
command_executor=cls.sauce_url)
cls.browser.implicitly_wait(30)
# remote screen may not be large enough for the whole page
cls.browser.set_window_size(cls.BROWSER_WIDTH, cls.BROWSER_HEIGHT)
def setUpFFWindowsSauceLabs(self, test_name):
print "Test case start"
self.sauce_client = SauceClient(baseTest.sauce_username, baseTest.sauce_access_key)
desired_cap = {
'platform': "Windows 10",
'browserName': "firefox",
'version': "62.0",
'screenResolution' : "1920x1080",
'name' : baseTest.sampleTestName,
}
self.driver = webdriver.Remote(
command_executor='https://{}:{}@ondemand.saucelabs.com/wd/hub'.format(baseTest.sauce_username, baseTest.sauce_access_key),
desired_capabilities=desired_cap)
return self.driver
def teardown(scenario):
step_results = []
passed = True
sauce_client = SauceClient(username, access_key)
session_id = scenario.steps[0].browser.session_id
for step in scenario.steps:
step.browser.quit()
step_results.append(step.passed)
for result in step_results:
if result != True:
passed = False
sauce_client.jobs.update_job(session_id, passed=passed)
print "SauceOnDemandSessionID=" + session_id + " job-name=" + scenario.name
def setUpFFSauceLabs(self, test_name):
print "Test case start"
#username = os.environ['SAUCE_USERNAME']
#access_key = os.environ['SAUCE_ACCESS_KEY']
self.sauce_client = SauceClient(baseTest.sauce_username, baseTest.sauce_access_key)
desired_cap = {
'platform': "macOS 10.13",
'browserName': "firefox",
'version': "64.0",
'screenResolution' : "1920x1440",
'name' : baseTest.sampleTestName,
}
self.driver = webdriver.Remote(
command_executor='https://{}:{}@ondemand.saucelabs.com/wd/hub'.format(baseTest.sauce_username, baseTest.sauce_access_key),
desired_capabilities=desired_cap)
return self.driver
def setUp(self):
# self.driver = webdriver.Firefox()
self.sauce_client = SauceClient(
"yoavikz", 'b465e2dc-2485-4ed6-9ced-502738b61f61')
SAUCE_USERNAME = '******'
SAUCE_ACCESS_KEY = 'b465e2dc-2485-4ed6-9ced-502738b61f61'
self.driver = webdriver.Remote(
desired_capabilities=webdriver.DesiredCapabilities.FIREFOX,
command_executor='http://%s:%[email protected]:80/wd/hub' %
(SAUCE_USERNAME, SAUCE_ACCESS_KEY))
id = self.driver.session_id
print 'Link to your job: https://saucelabs.com/jobs/%s' % id
self.driver.implicitly_wait(30)
self.base_url = "http://spectory-web.herokuapp.com"
self.verificationErrors = []
self.accept_next_alert = True
def tearDown(self):
if (os.environ.get('TRAVIS') == 'true'):
print("Link to job : https://saucelabs.com/jobs/%s" %
self.driver.session_id)
sauce_client = SauceClient(self.sauce_username, self.access_key)
try:
if sys.exc_info() == (None, None, None):
sauce_client.jobs.update_job(self.driver.session_id,
passed=True)
else:
sauce_client.jobs.update_job(self.driver.session_id,
passed=False)
finally:
self.driver.quit()
self.assertEqual([], self.verificationErrors)
else:
self.driver.quit()
self.assertEqual([], self.verificationErrors)
def before_all(context):
"""
Get behave.ini configs and start saucelabs client.
VARS:
context.userdata: Behave ini usardata fields params
context.sc: SauceClient class loged in context
context.storage: Storage class to upload and check sauce files
"""
context.userdata = context.config.userdata
context.apk_name = context.userdata['apk']
context.apk_path = context.userdata['apk_path']
context.device = context.userdata['device']
context.version = context.userdata['platform_version']
context.target = context.userdata['target']
context.optional_caps = context.userdata['optional_caps']
context.sc = SauceClient(environ['SAUCE_USER'], environ['SAUCE_KEY'])
context.storage = Storage(context.sc)
def tearDown(self):
logger = logging.getLogger()
if self.travis:
print("Link to test {}: https://app.saucelabs.com/jobs/{}".format(
self.__get_name_of_test(), self.driver.session_id))
sauce_client = SauceClient(self.sauce_username, self.access_key)
if sys.exc_info() == (None, None, None):
sauce_client.jobs.update_job(self.driver.session_id,
passed=True)
else:
sauce_client.jobs.update_job(self.driver.session_id,
passed=False)
try:
self.driver.quit()
except WebDriverException as e:
logger.warn('{}: ignored'.format(str(e)))
self.assertEqual([], self.verificationErrors)
def setUp(self):
if browser == 'Sauce':
self.desired_capabilities['name'] = self.id()
if os.environ.has_key('TRAVIS_JOB_NUMBER'):
self.desired_capabilities['tunnel-identifier'] = os.environ[
'TRAVIS_JOB_NUMBER']
self.desired_capabilities['build'] = os.environ[
'TRAVIS_BUILD_NUMBER']
self.desired_capabilities['tags'] = [
os.environ['TRAVIS_PYTHON_VERSION'], 'CI'
]
sauce_url = "http://%s:%[email protected]:80/wd/hub"
self.sauce = SauceClient(sauce_username, sauce_accesskey)
self.driver = webdriver.Remote(
desired_capabilities=self.desired_capabilities,
command_executor=sauce_url % (sauce_username, sauce_accesskey))
self.driver.implicitly_wait(5)
else:
self.driver = getattr(webdriver, browser)()
self.driver.implicitly_wait(3)
def set_webdriver(self):
# saucelabs
if self.drivertype == "sauce":
# travisci environment variables
self.USE_SAUCE = True
username = os.environ.get(
'SAUCE_USERNAME',
self.saucelab_environment_details.get('username', ''))
access_key = os.environ.get(
'SAUCE_ACCESS_KEY',
self.saucelab_environment_details.get('key', ''))
self.Sauce_Client = SauceClient(username, access_key)
self.saucelab_environment_details['username'] = username
self.saucelab_environment_details['key'] = access_key
self.webdriver = webdriver.Remote(
command_executor='http://%s:%[email protected]:80/wd/hub'
% (username, access_key),
desired_capabilities=self.saucelab_environment_details)
elif self.drivertype == "chrome":
if sys.platform == 'darwin':
chromedriver = "../chromedriver_mac"
elif sys.platform.startswith('linux'):
chromedriver = "../chromedriver_linux"
else:
print "You need to run these scripts with Mac or Linux(currently not supporting Windows)."
exit()
self.webdriver = webdriver.Chrome(chromedriver)
# default firefox webdriver
else:
if sys.platform == 'darwin':
os.environ["PATH"] += ':%s' % os.path.abspath("../mac")
elif sys.platform.startswith('linux'):
os.environ["PATH"] += ':%s' % os.path.abspath("../linux")
else:
print "You need to run these scripts with Mac or Linux(currently not supporting Windows)."
exit()
profile = webdriver.FirefoxProfile()
profile.set_preference("xpinstall.signatures.required", False)
self.webdriver = webdriver.Firefox(firefox_profile=profile)
def method_utilities_compare_all_success_failure(
farg, *args): # variable number of arguments
#chrome_web_driver = args[0]
session = ""
#print("**********************"+session)
ssl._create_default_https_context = ssl._create_unverified_context
for arg in args:
if isinstance(arg, str):
session = arg
print("********************** FOUND" + session)
sauce_client = SauceClient("mdhasan1234",
"ee94f3c5-92a6-4cd3-b1b0-842520ff0fac")
for arg in args:
if isinstance(arg, list):
for one_element in arg:
if 'failure' in str(one_element):
sauce_client.jobs.update_job(session, passed=False)
return "FAIL"
sauce_client.jobs.update_job(session, passed=True)
print('All steps were successfully executed')
return "PASS"
def finish_testing(success, driver):
print "Success - " + success
#send result back to saucelab to update the tests
sauce_client = SauceClient("YOUR_SAUCE_USERNAME", "YOUR_SAUCE_ACCESSKEY")
sauce_client.jobs.update_job(driver.session_id, passed=success)
# create etst results to be sent to Slack notifications
comment = "Test FAILED - <https://saucelabs.com/jobs/%s" % driver.session_id + "|Watch the video> for details"
if success:
comment = "Test PASSED! - <https://saucelabs.com/jobs/%s" % driver.session_id + "|Watch the video> for details"
global test_results
test_results.append(comment)
#write results to file
print len(test_results)
print len(desired_caps)
if len(test_results) == len(desired_caps):
print 'sending data...'
webhook_url = 'https://hooks.slack.com/services/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'
message = ""
for result in test_results:
message = message + "\n" + result
slack_data = {'Setup test results': message}
response = requests.post(webhook_url,
data=json.dumps(slack_data),
headers={'Content-Type': 'application/json'})
if response.status_code != 200:
raise ValueError(
'Request to slack returned an error %s, the response is:\n%s' %
(response.status_code, response.text))
driver.quit()
from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options
from sauceclient import SauceClient
import os, time, datetime
username = os.environ['SAUCE_USERNAME']
access_key = os.environ['SAUCE_ACCESS_KEY']
sauce_client = SauceClient(username, access_key)
chrome_options = Options()
chrome_options.add_argument("--disable-web-security")
now = datetime.datetime.now()
# build_name = "8-stepper-nosleep-google-%d" % (now.day)
build_name = os.environ['BUILDNAME']
test_name = "8-stepper-prod-%d:%d:%d" % (now.hour, now.minute, now.microsecond)
desired_caps = {
'platform': "macos 10.13",
'browserName': "Chrome",
'version': "69",
'build': build_name,
'name': test_name,
'chromedriverVersion': "2.42"
}
try:
driver = webdriver.Remote(
if REMOTE_SERVER_URL:
BaseTestCase = unittest.TestCase
else:
BaseTestCase = StaticLiveServerTestCase
assert socket.gethostbyname(LOCAL_SERVER_DOMAIN) in (
'0.0.0.0', '127.0.0.1'
), "Please add `127.0.0.1 " + LOCAL_SERVER_DOMAIN + "` to your hosts file before running this test."
# (2) Configure Sauce vs. local PhantomJS browsers vs. containerized Chrome:
if settings.USE_SAUCE:
from sauceclient import SauceClient
assert settings.SAUCE_USERNAME and settings.SAUCE_ACCESS_KEY, "Please make sure that settings.SAUCE_USERNAME and settings.SAUCE_ACCESS_KEY are set."
sauce = SauceClient(settings.SAUCE_USERNAME, settings.SAUCE_ACCESS_KEY)
# options: https://saucelabs.com/platforms
browsers = [
# Chrome
{
"platform": "Mac OS X 10.10",
"browserName": "chrome",
"version": "45"
},
{
"platform": "Windows 7",
"browserName": "chrome",
"version": "45"
},
if os.getenv('SAUCE_LABS') and os.getenv('SAUCE_USERNAME') and os.getenv('SAUCE_ACCESS_KEY'):
build_id = os.getenv('TRAVIS_BUILD_ID') or datetime.now().strftime('%business %d, %Y %H:%M:%S')
build_name = 'Python Sample Code %s' % build_id
ANDROID_BASE_CAPS['build'] = build_name
ANDROID_BASE_CAPS['tags'] = ['e2e', 'appium', 'sample-code', 'android', 'python']
ANDROID_BASE_CAPS['app'] = 'http://appium.github.io/appium/assets/ApiDemos-debug.apk'
IOS_BASE_CAPS['build'] = build_name
IOS_BASE_CAPS['tags'] = ['e2e', 'appium', 'sample-code', 'ios', 'python']
IOS_BASE_CAPS['app'] = 'http://appium.github.io/appium/assets/TestApp9.4.app.zip'
EXECUTOR = 'http://{}:{}@ondemand.saucelabs.com:80/wd/hub'.format(
os.getenv('SAUCE_USERNAME'), os.getenv('SAUCE_ACCESS_KEY'))
sauce = SauceClient(os.getenv('SAUCE_USERNAME'), os.getenv('SAUCE_ACCESS_KEY'))
else:
EXECUTOR = 'http://127.0.0.1:4723/wd/hub'
def ensure_dir(directory):
if not os.path.exists(directory):
os.makedirs(directory)
def take_screenshot_and_logcat(driver, device_logger, calling_request):
__save_log_type(driver, device_logger, calling_request, 'logcat')
def take_screenshot_and_syslog(driver, device_logger, calling_request):
__save_log_type(driver, device_logger, calling_request, 'syslog')