def start_local():
"""Starts BrowserStack Local"""
global bs_local
bs_local = Local()
bs_local_args = {
"key": CONFIG['capabilities']['browserstack.key'],
"forcelocal": "true"
}
bs_local.start(**bs_local_args)
def test_multiple(self):
self.assertFalse(self.local.isRunning())
self.local.start()
self.assertTrue(self.local.isRunning())
try:
self.local2 = Local(os.environ['BROWSERSTACK_ACCESS_KEY'])
self.local2.start()
except BrowserStackLocalError as e:
self.assertEqual(str(e), "Either another browserstack local client is running on your machine or some server is listening on port 45691")
def start_local():
try:
# creates an instance of Local
BS_LOCAL = Local()
# replace <browserstack-accesskey> with your key. You can also set an environment variable - "BROWSERSTACK_ACCESS_KEY".
bs_local_args = {"key": BROWSERSTACK_ACCESS_KEY}
# starts the Local instance with the required arguments
BS_LOCAL.start(**bs_local_args)
# check if BrowserStack local instance is running
print("bs_local running:", BS_LOCAL.isRunning())
except Exception as e:
print('Exception occured while instantiating web driver locally' + str(e))
def connect_bs_to_local(key):
""" Create a connection between Browserstack and localhost """
from browserstack.local import Local
bs_local = Local()
bs_local_args = {
"key": key,
"forcelocal": "true",
}
bs_local.start(**bs_local_args)
logger.info('Browerstack local connection:', bs_local.isRunning())
# The default Browserstack local.stop() isn't working for some reason.
# But actually there is no need to close the connection as it is running inside a Docker container that gets killed after the test is done.
# def stop_bs_local():
# bs_local.stop()
def browserstack_local(access_key):
"""Start browserstack local tool as a background process"""
# TODO This can be deprecated once
# https://github.com/browserstack/browserstack-local-python/pull/28 is
# merged (it may not be merged because it's a relatively inactive repo)
local = Local(key=access_key)
try:
local.start()
yield local
finally:
local.stop()
def run_suite(self, suite, **kwargs):
"""Override run_suite with a for loop function."""
suite._cleanup = False
bs_local = Local()
bs_local_args = {"forcelocal": "true"}
bs_local.start(**bs_local_args)
print( # noqa: T001
"Browser stack is %srunning..." %
("" if bs_local.isRunning() else "not "))
result = {}
for cap in getattr(settings, "BROWSERSTACK_CAPS", {}):
settings.WEBDRIVER = cap
kwargs = self.get_test_runner_kwargs()
runner = self.test_runner(**kwargs)
result = runner.run(suite)
# return last result.. not sure how to merge them
bs_local.stop()
return result
class TestBrowserStackSearch(unittest.TestCase):
_multiprocess_shared_ = True
driver = None
bs_local = None
@classmethod
def create_driver(self):
desired_capabilities = TestBrowserStackSearch.get_caps()
return webdriver.Remote(
desired_capabilities=desired_capabilities,
command_executor="http://%s:%[email protected]/wd/hub" %
(USERNAME, BROWSERSTACK_ACCESS_KEY))
@classmethod
def get_caps(self):
desired_capabilities = {}
desired_capabilities['os'] = 'OS X'
desired_capabilities['os_version'] = 'El Capitan'
desired_capabilities['browser'] = 'firefox'
desired_capabilities['browser_version'] = '46'
desired_capabilities['build'] = 'Sample python tests using unittest'
desired_capabilities['name'] = 'Sample python unittest'
if 'local' in test_type.lower():
desired_capabilities['browserstack.local'] = True
return desired_capabilities
@classmethod
def start_local(self):
self.bs_local = Local()
bs_local_args = {"key": "sUiJatw6NhJZpsttcY35", "forcelocal": "true"}
self.bs_local.start(**bs_local_args)
@classmethod
def stop_local(self):
if self.bs_local is not None:
self.bs_local.stop()
@classmethod
def setUpClass(self):
if 'local' in test_type.lower():
self.start_local()
if 'parallel' not in test_type.lower():
self.driver = TestBrowserStackSearch.create_driver()
@classmethod
def tearDownClass(self):
self.stop_local()
if 'parallel' not in test_type.lower():
self.driver.quit()
def setUp(self):
if 'parallel' in test_type.lower():
self.driver = TestBrowserStackSearch.create_driver()
def tearDown(self):
if 'parallel' in test_type.lower():
self.driver.quit()
def test_google_search(self):
self.driver.get("http://www.google.com")
if not "Google" in self.driver.title:
raise Exception("Unable to load google page!")
elem = self.driver.find_element_by_name("q")
elem.send_keys("BrowserStack")
elem.submit()
self.assertTrue("browserstack" in self.driver.title.lower())
def test_google_search_clone(self):
self.driver.get("http://www.google.com")
if not "Google" in self.driver.title:
raise Exception("Unable to load google page!")
elem = self.driver.find_element_by_name("q")
elem.send_keys("BrowserStack")
elem.submit()
self.assertTrue("browserstack" in self.driver.title.lower())
def start_local():
global bs_local
bs_local = Local()
bs_local_args = {"key": accessKey, "forcelocal": "true"}
bs_local.start(**bs_local_args)
def start_local():
"""Code to start browserstack local before start of test."""
global bs_local
bs_local = Local()
bs_local_args = { "key": CONFIG['capabilities']['browserstack.key'], "forcelocal": "true" }
bs_local.start(**bs_local_args)
def Download_file_to_machine(self):
desired_cap = {
"browser": "chrome",
"browser_version": "latest",
"os": "windows",
"os_version": "10",
'build': 'Teladoc',
'name': 'Teladoc Test',
'browserstack.local': 'true'
}
bs_local = Local()
# You can also set an environment variable - "BROWSERSTACK_ACCESS_KEY".
bs_local_args = {
"key": "yourKey",
"f": "/Users/yourFolder/Documents/Local_Testing/Local"
}
# Starts the Local instance with the required arguments
bs_local.start(**bs_local_args)
# Check if BrowserStack local instance is running
print(bs_local.isRunning())
driver = webdriver.Remote(
desired_capabilities=desired_cap,
command_executor=
'https://*****:*****@hub-cloud.browserstack.com/wd/hub')
# Navigate to the link
driver.get("http://username.browserstack.com")
# Accept the cookie popup
time.sleep(2)
url = 'download/11_01_2020 01_26 AM PDT — 11_10_2020 05_26 AM PST.xml'
# Find element by class name and store in variable "element"
element = driver.find_element_by_xpath('//a[@href="' + url + '"]')
time.sleep(2)
# Click on the element to download the file
element.click()
time.sleep(2)
# Check if file exists
file_exists = driver.execute_script(
'browserstack_executor: {"action": "fileExists"}')
print(file_exists)
# Check file properties
file_properties = driver.execute_script(
'browserstack_executor: {"action": "getFileProperties"}')
print(file_properties)
get_file_content = driver.execute_script(
'browserstack_executor: {"action": "getFileContent"}')
time.sleep(2)
# Decode the content to Base64 and write to a file
data = base64.b64decode(get_file_content)
f = open("11_01_2020 01_26 AM PDT — 11_10_2020 05_26 AM PST.xml", "wb")
f.write(data)
# Stop the Local instance
bs_local.stop()
driver.quit()
def start_local(self):
self.bs_local = Local()
bs_local_args = { "key": "sUiJatw6NhJZpsttcY35", "forcelocal": "true" }
self.bs_local.start(**bs_local_args)
class TestBrowserStackSearch(unittest.TestCase):
_multiprocess_shared_ = True
driver = None
bs_local = None
@classmethod
def create_driver(self):
desired_capabilities = TestBrowserStackSearch.get_caps()
return webdriver.Remote(
desired_capabilities=desired_capabilities,
command_executor="http://%s:%[email protected]/wd/hub" % (
USERNAME, BROWSERSTACK_ACCESS_KEY
)
)
@classmethod
def get_caps(self):
desired_capabilities = {}
desired_capabilities['os'] = 'OS X'
desired_capabilities['os_version'] = 'El Capitan'
desired_capabilities['browser'] = 'firefox'
desired_capabilities['browser_version'] = '46'
desired_capabilities['build'] = 'Sample python tests using unittest'
desired_capabilities['name'] = 'Sample python unittest'
if 'local' in test_type.lower():
desired_capabilities['browserstack.local'] = True
return desired_capabilities
@classmethod
def start_local(self):
self.bs_local = Local()
bs_local_args = { "key": "sUiJatw6NhJZpsttcY35", "forcelocal": "true" }
self.bs_local.start(**bs_local_args)
@classmethod
def stop_local(self):
if self.bs_local is not None:
self.bs_local.stop()
@classmethod
def setUpClass(self):
if 'local' in test_type.lower():
self.start_local()
if 'parallel' not in test_type.lower():
self.driver = TestBrowserStackSearch.create_driver()
@classmethod
def tearDownClass(self):
self.stop_local()
if 'parallel' not in test_type.lower():
self.driver.quit()
def setUp(self):
if 'parallel' in test_type.lower():
self.driver = TestBrowserStackSearch.create_driver()
def tearDown(self):
if 'parallel' in test_type.lower():
self.driver.quit()
def test_google_search(self):
self.driver.get("http://www.google.com")
if not "Google" in self.driver.title:
raise Exception("Unable to load google page!")
elem = self.driver.find_element_by_name("q")
elem.send_keys("BrowserStack")
elem.submit()
self.driver.find_element_by_name("btnG").click()
self.assertTrue("browserstack" in self.driver.title.lower())
def test_google_search_clone(self):
self.driver.get("http://www.google.com")
if not "Google" in self.driver.title:
raise Exception("Unable to load google page!")
elem = self.driver.find_element_by_name("q")
elem.send_keys("BrowserStack")
elem.submit()
self.driver.find_element_by_name("btnG").click()
self.assertTrue("browserstack" in self.driver.title.lower())
from selenium import webdriver
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
import os, time, requests
from browserstack.local import Local
BROWSERSTACK_USERNAME = os.environ['BROWSERSTACK_USERNAME']
BROWSERSTACK_ACCESS_KEY = os.environ['BROWSERSTACK_ACCESS_KEY']
bs_local = Local()
bs_local_args = {"key": BROWSERSTACK_ACCESS_KEY}
bs_local.start(**bs_local_args)
# print ("Success starting local!!")
desired_cap = {
'browser': 'Chrome',
'browser_version': '75.0',
'os': 'Windows',
'os_version': '7',
'resolution': '1024x768',
'browserstack.local': 'true', # LOCAl CAPABILITY
'name': 'Python Local APIs',
'build': 'Python Demo'
}
try:
driver = webdriver.Remote(
command_executor='https://%s:%[email protected]/wd/hub' %
(BROWSERSTACK_USERNAME, BROWSERSTACK_ACCESS_KEY),
desired_capabilities=desired_cap)
print("Local Test Started")
def start_local(self):
self.bs_local = Local()
bs_local_args = {"key": "sUiJatw6NhJZpsttcY35", "forcelocal": "true"}
self.bs_local.start(**bs_local_args)
"""
Created on Sun Apr 22 12:51:22 2018
@author: sumkumar
"""
import fast_selenium
from common import postOmnitureData
#postOmnitureData()
import gsheet
from common import start_time
from common import datetime
from common import test_runner
from browserstack.local import Local
#creates an instance of Local
bs_local = Local()
#replace <browserstack-accesskey> with your key. You can also set an environment variable - "BROWSERSTACK_ACCESS_KEY".
bs_local_args = {"key": "", "forcelocal": "true"}
#starts the Local instance with the required arguments
bs_local.start(**bs_local_args)
#check if BrowserStack local instance is running
print(bs_local.isRunning())
big_dict = gsheet.big_dict
gc = gsheet.gc
wks = gc.open("BoomAudit").worksheet('PWA Logs')
#print(big_dict)
def get_browser_instance(self):
try:
if self.browser.lower() == "firefox":
options = FirefoxOptions()
if self.headless:
options.add_argument("--headless")
options.add_argument("-width=1920")
options.add_argument("-height=1080")
# options.add_argument("--disable-gpu")
profile = webdriver.FirefoxProfile()
# options.add_argument("--private")
profile.accept_untrusted_certs = True
service = Service(executable_path=GeckoDriverManager(
cache_valid_range=10).install())
driver = webdriver.Firefox(service=service,
firefox_profile=profile,
options=options)
elif self.browser.lower() == "chrome":
options = ChromeOptions()
if self.headless:
options.add_argument('headless')
options.add_argument('window-size=1920x1080')
if self.mobile:
mobile_emulation = {"deviceName": self.device}
options.add_experimental_option("mobileEmulation",
mobile_emulation)
options.add_argument('ignore-certificate-errors')
options.add_argument('--incognito')
# options.add_argument('--start-maximized')
options.add_experimental_option('useAutomationExtension',
False)
options.add_experimental_option("excludeSwitches",
["enable-automation"])
# options.add_experimental_option("excludeSwitches", ["enable-logging"])
options.add_argument('--log-level=3')
service = Service(
ChromeDriverManager(cache_valid_range=10).install())
driver = webdriver.Chrome(service=service, options=options)
elif self.browser.lower() == "ie":
driver = webdriver.Ie(IEDriverManager().install())
elif self.browser.lower() == "edge":
options = EdgeOptions()
if self.headless:
options.add_argument('headless')
options.add_argument('window-size=1920x1080')
options.use_chromium = True
options.add_argument('ignore-certificate-errors')
options.add_experimental_option('useAutomationExtension',
False)
options.add_argument('--inprivate')
options.add_argument('--log-level=3')
options.add_experimental_option("excludeSwitches",
["enable-automation"])
service = Service(
EdgeChromiumDriverManager(cache_valid_range=10,
log_level=1).install())
driver = webdriver.Chrome(service=service, options=options)
elif self.browser.lower() == 'browserstack':
bs_local = Local()
bs_local_args = {
"key": key,
"localIdentifier": localIdentifier
}
bs_local.start(**bs_local_args)
driver = webdriver.Remote(command_executor=bb_url,
desired_capabilities=browser_config)
# elif self.browser.lower() =="docker":
# options = FirefoxOptions()
# options.add_argument("--headless")
# options.add_argument("-width=1920")
# options.add_argument("-height=1080")
# profile = webdriver.FirefoxProfile()
# # options.add_argument("--private")
# profile.accept_untrusted_certs = True
# driver = webdriver.Remote(command_executor="http://localhost:4444", options=options, browser_profile=profile)
else:
raise ValueError
if self.headless:
self.cl.info("Starting " + str(self.browser).upper() +
" browser in headless mode")
else:
self.cl.info("Starting " + str(self.browser).upper() +
" browser ")
if self.browser.lower(
) == "browserstack" and 'browserName' in browser_config.keys():
pass
else:
driver.maximize_window()
driver.delete_all_cookies()
# driver.set_page_load_timeout(30)
if self.baseUrl:
driver.get(self.baseUrl)
self.cl.info("Opening the URL :: " + str(self.baseUrl))
# driver.implicitly_wait(10)
return driver
except ValueError as val:
self.cl.error(
"Browser not supported :: " + str(self.browser) +
". Supported browser types are Chrome, Firefox, Edge. Exception occurred. :: "
+ str(val.__class__.__name__) + ' ' + str(val))
raise val
except Exception as e:
self.cl.error("Exception occurred. :: " +
str(e.__class__.__name__) + ' ' + str(e))
raise e
def setUp(self):
self.local = Local('sKUQixMHzMLvVtAqysUN')
class TestLocal(unittest.TestCase):
def setUp(self):
self.local = Local('sKUQixMHzMLvVtAqysUN')
def tearDown(self):
self.local.stop()
def test_start_local(self):
self.local.start()
self.assertNotEqual(self.local.proc.pid, 0)
def test_verbose(self):
self.local.verbose(True)
self.assertTrue('-v' in self.local._generate_args())
def test_local_folder(self):
self.local.local_folder('hello')
self.assertTrue('-f' in self.local._generate_args())
self.assertTrue('hello' in self.local._generate_args())
def test_force_kill(self):
self.local.force_kill(True)
self.assertTrue('-force' in self.local._generate_args())
def test_only_automate(self):
self.local.only_automate(True)
self.assertTrue('-onlyAutomate' in self.local._generate_args())
def test_force_local(self):
self.local.force_local(True)
self.assertTrue('-forcelocal' in self.local._generate_args())
def test_proxy(self):
self.local.proxy('localhost', 2000, 'hello', 'test123')
self.assertTrue(
"-proxyHost localhost -proxyPort 2000 -proxyUser hello -proxyPass test123"
in self.local._generate_args())
def test_local_identifier(self):
self.local.local_identifier('mytunnel')
self.assertTrue(
'-localIdentifier mytunnel' in self.local._generate_args())
def test_context_manager(self):
with Local('BROWSERSTACK_ACCESS_KEY') as local:
self.assertNotEqual(local.proc.pid, 0)
def start_local():
"""Code to start browserstack local before start of test."""
global bs_local
bs_local = Local()
bs_local_args = { "key": BROWSERSTACK_ACCESS_KEY, "forcelocal": "true" }
bs_local.start(**bs_local_args)
class TestLocal(unittest.TestCase):
def setUp(self):
self.local = Local(os.environ['BROWSERSTACK_ACCESS_KEY'])
def tearDown(self):
self.local.stop()
def test_start_local(self):
self.local.start()
self.assertNotEqual(self.local.proc.pid, 0)
def test_running(self):
self.assertFalse(self.local.isRunning())
self.local.start()
self.assertTrue(self.local.isRunning())
def test_multiple(self):
self.assertFalse(self.local.isRunning())
self.local.start()
self.assertTrue(self.local.isRunning())
try:
self.local2 = Local(os.environ['BROWSERSTACK_ACCESS_KEY'])
self.local2.start()
except BrowserStackLocalError as e:
self.assertEqual(str(e), "Either another browserstack local client is running on your machine or some server is listening on port 45691")
def test_verbose(self):
self.local.start(v=True, onlyCommand=True)
self.assertIn('-v', self.local._generate_cmd())
def test_local_folder(self):
self.local.start(f='hello', onlyCommand=True)
self.assertIn('-f', self.local._generate_cmd())
self.assertIn('hello', self.local._generate_cmd())
def test_force_kill(self):
self.local.start(force=True, onlyCommand=True)
self.assertIn('-force', self.local._generate_cmd())
def test_only_automate(self):
self.local.start(onlyAutomate=True, onlyCommand=True)
self.assertIn('-onlyAutomate', self.local._generate_cmd())
def test_force_local(self):
self.local.start(forcelocal=True, onlyCommand=True)
self.assertIn('-forcelocal', self.local._generate_cmd())
def test_custom_boolean_argument(self):
self.local.start(boolArg1=True, boolArg2=True, onlyCommand=True)
self.assertIn('-boolArg1', self.local._generate_cmd())
self.assertIn('-boolArg2', self.local._generate_cmd())
def test_custom_keyval(self):
self.local.start(customKey1="custom value1", customKey2="custom value2", onlyCommand=True)
self.assertIn('-customKey1', self.local._generate_cmd())
self.assertIn('custom value1', self.local._generate_cmd())
self.assertIn('-customKey2', self.local._generate_cmd())
self.assertIn('custom value2', self.local._generate_cmd())
def test_proxy(self):
self.local.start(proxyHost='localhost', proxyPort=2000, proxyUser='******', proxyPass='******', onlyCommand=True)
self.assertIn('-proxyHost', self.local._generate_cmd())
self.assertIn('localhost', self.local._generate_cmd())
self.assertIn('-proxyPort', self.local._generate_cmd())
self.assertIn(2000, self.local._generate_cmd())
self.assertIn('-proxyUser', self.local._generate_cmd())
self.assertIn('hello', self.local._generate_cmd())
self.assertIn('-proxyPass', self.local._generate_cmd())
self.assertIn('test123', self.local._generate_cmd())
def test_force_proxy(self):
self.local.start(forceproxy=True, onlyCommand=True)
self.assertIn('-forceproxy', self.local._generate_cmd())
def test_local_identifier(self):
self.local.start(localIdentifier='mytunnel', onlyCommand=True)
self.assertIn('-localIdentifier', self.local._generate_cmd())
self.assertIn('mytunnel', self.local._generate_cmd())
def start_local():
"""Code to start browserstack local before start of test."""
global bs_local
bs_local = Local()
bs_local_args = { "key": BROWSERSTACK_ACCESS_KEY, "forcelocal": "true" }
bs_local.start(**bs_local_args)
def setUp(self): self.local = Local(os.environ['BROWSERSTACK_ACCESS_KEY'])
