def function_driver(request):
browser = request.config.getoption("--browser")
browser_opt = request.config.getoption("--browser_opt")
print("获取命令行传参：{}".format(request.config.getoption("--browser")))
# 是否开启浏览器设置，根据命令行传参，browser_opt判断，默认open
if browser_opt == "open":
if browser == "chrome":
driver = webdriver.Chrome()
elif browser == "firefox":
driver = webdriver.Firefox()
elif browser == "ie":
driver = webdriver.Ie()
else:
logging.info("发送错误浏览器参数：{}".format(browser))
else:
if browser == "chrome":
chrome_options = CO()
chrome_options.add_argument('--headless')
driver = webdriver.Chrome(chrome_options=chrome_options)
elif browser == "firefox":
firefox_options = FO()
firefox_options.add_argument('--headless')
driver = webdriver.Firefox(firefox_options=firefox_options)
elif browser == "ie":
ie_options = IEO()
ie_options.add_argument('--headless')
driver = webdriver.Ie(ie_options=ie_options)
else:
logging.info("发送错误浏览器参数：{}".format(browser))
yield driver
# driver.close()
driver.quit()
def __init__(
self,
ie_options: Options = None,
desired_capabilities: dict = None,
token: str = None,
project_name: str = None,
job_name: str = None,
disable_reports: bool = False,
):
# If no options or capabilities are specified at all, use default Options
if ie_options is None and desired_capabilities is None:
caps = Options().to_capabilities()
else:
# Specified IE Options take precedence over desired capabilities but either can be used
caps = (
ie_options.to_capabilities()
if ie_options is not None
else desired_capabilities
)
super().__init__(
capabilities=caps,
token=token,
project_name=project_name,
job_name=job_name,
disable_reports=disable_reports,
)
def __init__(self, browser):
self.browser = browser
chrome_options = self.chrome_options(options='start-maximized')
yandex_options = self.yandex_options(options='start-maximized')
if browser == 'yandex':
self.driver = webdriver.Chrome(
executable_path='C:/1/chromedriver.exe',
chrome_options=yandex_options)
elif browser == 'ie':
ie_options = Options()
ie_options.ignore_protected_mode_settings = True
ie_options.ignore_zoom_level = True
self.driver = webdriver.Ie(
executable_path=r'C:\1\IEDriverServer.exe', options=ie_options)
elif browser == 'chrome':
self.driver = webdriver.Chrome(
executable_path='C:/1/chromedriver.exe',
chrome_options=chrome_options)
elif browser == 'firefox':
self.driver = webdriver.Chrome(
executable_path='C:/1/gekodriver.exe')
else:
raise ValueError
self.wiki = WikiMainHepler(self)
self.driver.implicitly_wait(2)
def __init__(self):
opts = Options()
# opts.ignore_protected_mode_settings = True
opts.require_window_focus = True
opts.ignore_zoom_level = True
self.browser = webdriver.Ie("drivers\\32bit_IEDriverServer.exe",
options=opts)
def test_ie_compatibility_session():
options = IEOptions()
options.attach_to_edge_chrome = True
options.edge_executable_path = "/path/to/edge/browser"
driver = webdriver.Ie(options=options)
driver.quit()
def test_launch_ie_with_options(pages):
opts = Options()
expected = "clicks.html"
opts.initial_browser_url = pages.url(expected)
driver = Ie(options=opts)
actual = driver.current_url
driver.quit()
assert expected in actual
def connect_ie_driver(headless):
"""Function to connect with ie driver """
#initialise chrome options
options = IeOptions()
#set headless option on driver
options.headless = headless
#initialise driver
driver = webdriver.Ie(IEDriverManager().install(), options=options)
return driver
def _process_ie_options(self, opts):
from selenium.webdriver.ie.options import Options
if isinstance(opts, Options):
options = opts
else:
options = Options()
if 'args' in opts:
for arg in opts.pop('args'):
options.add_argument(arg)
self.selenium_opts['options'] = options
def __init__(self):
super(SelDriver, self).__init__()
opts = Options()
opts.ignore_protected_mode_settings = True
opts.ignore_zoom_level = True
dir = os.path.dirname(os.path.abspath(__file__))
path = dir + r'\\asset\\selenium\\chromedriver.exe'
self.driver = webdriver.Chrome(executable_path=path, chrome_options=opts)
self.access()
self.login()
def _create_IE_options(api_obj):
options = IEOptions()
args = set()
#not recommended, ensure correct security settings in IE
args.add(IEOptions.IGNORE_PROTECTED_MODE_SETTINGS)
args.add(IEOptions.ENSURE_CLEAN_SESSION)
args.add(IEOptions.IGNORE_ZOOM_LEVEL)
args.add(IEOptions.REQUIRE_WINDOW_FOCUS)
args.add(IEOptions.PERSISTENT_HOVER)
if api_obj.browser_options_args:
args.update(api_obj.browser_options_args)
for arg in args:
if arg:
options.add_argument(arg)
if api_obj.http_proxy:
proxy = {
'proxyType': "manual",
'httpProxy': str(api_obj.http_proxy)
}
options.set_capability("proxy", proxy)
options.set_capability(IEOptions.NATIVE_EVENTS, False)
if api_obj.browser_options_dict:
for k, v in api_obj.browser_options_dict.items():
options.set_capability(k, v)
return options
def function_driver(request):
"""
driver注入
@param request:
@return:
"""
browser = request.config.getoption("--browser")
# 用于本地启动是否开启浏览器设置，根据命令行传参，browser_opt判断，默认open
browser_opt = request.config.getoption("--browser_opt")
print("获取命令行传参：{}".format(request.config.getoption("--browser")))
type_driver = request.config.getoption("--type_driver")
# 判断是本地还是远程
if type_driver == "local":
if browser_opt == "open":
if browser == "chrome":
driver = webdriver.Chrome()
elif browser == "firefox":
driver = webdriver.Firefox()
elif browser == "ie":
driver = webdriver.Ie()
else:
logging.info("发送错误浏览器参数：{}".format(browser))
else:
if browser == "chrome":
chrome_options = CO()
chrome_options.add_argument('--headless')
driver = webdriver.Chrome(chrome_options=chrome_options)
elif browser == "firefox":
firefox_options = FO()
firefox_options.add_argument('--headless')
driver = webdriver.Firefox(firefox_options=firefox_options)
elif browser == "ie":
ie_options = IEO()
ie_options.add_argument('--headless')
driver = webdriver.Ie(ie_options=ie_options)
else:
logging.info("发送错误浏览器参数：{}".format(browser))
yield driver
# driver.close()
driver.quit()
elif type_driver == "remote":
driver = Remote(command_executor=selenium_config["selenium_config"]
["selenium_hub_url"],
desired_capabilities={
'platform': 'ANY',
'browserName': browser,
'version': '',
'javascriptEnabled': True
})
yield driver
# driver.close()
driver.quit()
else:
logging.error("driver参数传递错误，请检查参数：{}".format(type_driver))
def test_Notificacion_box(self):
Opciones = Options()
#enviar argumentos 1 = permitir notificacion, 2 = bloquear notificacion
Opciones.add_experimental_option(
"prefs",
{"profile.default_content_setting_values.notifications", 2})
driver = self.driver
driver.maximize_window()
driver.get("http://developer.mozilla.org/es/docs/web/API/notification")
print("Titulo de la aplicación: ", driver.title)
print("URL de la aplicación: ", driver.current_url)
self.assertIn("Notification - Referencia de la API Web | MDN",
driver.title)
time.sleep(3)
def __init__(
self,
ie_options: Options = Options(),
token: str = None,
projectname: str = None,
jobname: str = None,
disable_reports: bool = False,
):
super().__init__(
capabilities=ie_options.to_capabilities(),
token=token,
projectname=projectname,
jobname=jobname,
disable_reports=disable_reports,
)
def ie_settings(self, optional_settings=[None], optional_proxy=None):
# Definição das variáveis
ie_options = Options()
# Define as configurações adcionais do driver
ie_options.ignore_protected_mode_settings = True
# Inicia o driver e carrega as configurações
driver = webdriver.Ie(
IEDriverManager('').install('./driver/IEDriverServer_win.exe'),
options=ie_options)
# Retorna o driver configurado para a aplicação principal
return driver
class InternetExplorer(Browser):
_webdriver = Webdriver
_options = Options()
def __init__(self, **options):
"""
Initialize IE browser session with options provided.
:param options:
"""
[
self._options.add_argument(arg)
for arg in options.get('arguments', [])
]
[
self._options.add_additional_option(name, opt)
for name, opt in options.get('additional_options', {}).items()
]
def _override(self):
"""
Overrides link in case of certain exceptions.
:return:
"""
try:
self._session.get(
'javascript:document.getElementById("overridelink").click();')
except Exception as e:
print(type(e), e)
def browser_ie(browser_path="", driver_path=""):
"""
ie内核浏览器兼容，
:param browser_path: 浏览器路径，
:param driver_path: 驱动路径，
:return: driver，
"""
global driver
if len(browser_path) > 0:
options = IeOptions()
options.binary_location = browser_path
else:
options = None
if len(driver_path) == 0 :
driver_path = "IEDriverServer.exe"
driver = webdriver.Ie(executable_path=driver_path, options=options) # 需要在设置-安全-四个区域中统一启用安全模式，
return driver
def getWebDriverInstance(self):
baseURL = "https://learn.letskodeit.com/p/practice"
if self.browser == "ie":
driver_path = "C:\\DevTools\\webdriver\\IEDriverServer_win32_3.14.0.exe"
os.environ["webdriver.ie.driver"] = driver_path
options = IeOptions()
options.binary_location = "C:\\Program Files\\internet explorer\\iexplore.exe"
driver = webdriver.Ie(executable_path=driver_path,
options=options,
service_log_path='./Log/iedriver.log')
elif self.browser == 'firefox':
driver_path = "C:\\DevTools\\webdriver\\geckodriver_0.24.0.exe"
driver = webdriver.Firefox(
executable_path=driver_path,
service_log_path='./Log/geckodriver.log')
elif self.browser == 'chrome':
# https://chromedriver.chromium.org/downloads/version-selection
# PROD
driver_path = "C:\\DevTools\\webdriver\\chromedriver_76.0.3809.126.exe"
os.environ["webdriver.chrome.driver"] = driver_path
options = Options()
options.binary_location = "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"
driver = webdriver.Chrome(
executable_path=driver_path,
options=options,
service_log_path='./Log/chromedriver.log')
# DEV
# driver_path = "C:\\DevTools\\webdriver\\chromedriver_77.0.3865.40.exe"
# os.environ["webdriver.chrome.driver"] = driver_path
# options = Options()
# options.binary_location = "C:\\Program Files (x86)\\Google\\Chrome Dev\\Application\\chrome.exe"
# driver = webdriver.Chrome(executable_path=driver_path, options=options, service_log_path='./Log/chromedriver.log')
else:
driver_path = "C:\\DevTools\\webdriver\\geckodriver_0.24.0.exe"
driver = webdriver.Firefox(
executable_path=driver_path,
service_log_path='./Log/geckodriver.log')
driver.implicitly_wait(3)
driver.maximize_window()
driver.get(baseURL)
return driver
def connect_ie_driver(self):
"""Functions to connect with ie driver """
#initialise chrome options
self.options = IeOptions()
#add cookies on driver
self.options.add_argument("user-data-dir=selenium")
#initialise driver
self.driver = webdriver.Ie(IEDriverManager().install(),
ie_options=self.options)
return self.driver
def connect_firefox_driver(self):
"""Functions to connect with firefox driver """
#initialise chrome options
self.options = FirefoxOptions()
#add cookies on driver
self.options.add_argument("user-data-dir=selenium")
#initialise driver
self.driver = webdriver.Firefox(
executable_path=GeckoDriverManager().install(),
firefox_options=self.options)
return self.driver
class DriverSelectorIe:
"""
Concrete IE driver selector class
Methods
------
__init__(arguments)
sets up options for IE with arguments specified
get_webdriver_instance()
returns IE driver instance
"""
def __init__(self, arguments):
self.options = IeOptions()
for argument in arguments:
self.options.add_argument(argument)
def get_webdriver_instance(self):
return webdriver.Ie(options=self.options)
def open_browser(executable_path='IEDriverServer',
capabilities=None,
port=0, timeout=30, host=None, log_level=None, log_file=None,
options=None, ie_options=None):
capabilities = DesiredCapabilities.INTERNETEXPLORER.copy()
options = Options()
options.ignore_zoom_level = True
options.require_window_focus = True
options.ignore_protected_mode_settings = True
options.native_events = False
options.enable_persistent_hover = True
options.ensure_clean_session = True
options.javascript_enabled = True
driver = webdriver.Ie(executable_path, capabilities, port, timeout, host,
log_level, log_file, options, ie_options)
browser.cache_browser(driver)
return driver
def IEdrivernobrowser():
# 无头启动
IE_options = Options()
IE_options.add_argument("--headless")
IE_options.add_argument("--disable-gpu")
# 规避检测
option = IeOptions()
option.add_additional_option('excludeSwitches', ['enable-automation'])
driver = webdriver.Ie(ie_options=IE_options, options=option)
return driver
def mybrowser(browser):
driver = None
str1 = platform.platform()
op = str1.split("-")[0]
if op == "Linux":
if (browser.lower() == "firefox"):
Firefox_option = fireop()
fireop.add_argument('--headless')
driver = Firefox(executable_path=FIREFOX_DIR,
firefox_options=Firefox_option)
Logger.logger.info("启动火狐浏览器,请稍等")
driver.maximize_window()
if browser.lower() == "chrome":
Chrome_option = chop()
Chrome_option.add_argument('--headless')
driver = Chrome(executable_path=CHROME_DIR,
chrome_options=Chrome_option)
Logger.logger.info("启动谷歌浏览器,请稍等")
driver.maximize_window()
if browser.lower() == "ie":
op = Options()
op.add_argument('--headless')
op.set_capability(op.IGNORE_PROTECTED_MODE_SETTINGS, True)
driver = Ie(executable_path=IE_DIR, ie_options=op)
Logger.logger.info("启动ie浏览器,请稍等")
driver.maximize_window()
else:
if (browser.lower() == "firefox"):
driver = Firefox(executable_path=FIREFOX_DIR)
Logger.logger.info("启动火狐浏览器,请稍等")
driver.maximize_window()
if browser.lower() == "chrome":
driver = Chrome(executable_path=CHROME_DIR)
Logger.logger.info("启动谷歌浏览器,请稍等")
driver.maximize_window()
if browser.lower() == "ie":
op.set_capability(op.IGNORE_PROTECTED_MODE_SETTINGS, True)
driver = Ie(executable_path=IE_DIR)
Logger.logger.info("启动ie浏览器,请稍等")
driver.maximize_window()
return driver
def __init__(
self,
ie_options: Options = None,
desired_capabilities: dict = None,
token: str = None,
projectname: str = None,
jobname: str = None,
disable_reports: bool = False,
):
# Specified IE Options take precedence over desired capabilities but either can be used
caps = (ie_options.to_capabilities()
if ie_options is not None else desired_capabilities)
super().__init__(
capabilities=caps,
token=token,
projectname=projectname,
jobname=jobname,
disable_reports=disable_reports,
)
def ie_autoload():
ie_option = IOptions()
# 设置隐藏模式
ie_option.add_argument('--disable-gpu')
ie_option.add_argument('--no-sandbox')
ie_option.add_argument('--disable-dev-shm-usage')
ie_driver = webdriver.Ie(options=ie_option)
# 登陆网页保存cookie
try:
url1 = 'https://auth.xfmgroup.com/cas/login?' \
'service=http%3a%2f%2fmes.xfmgroup.com%2fWebUI%2fIPWeb%2f'
ie_driver.get(url1)
time.sleep(5)
ie_driver.find_element_by_xpath('//*[@id="fm1"]/div/div[3]/input[4]').click()
time.sleep(5)
# 进入需要计算的页面
url2 = 'http://fbbb.xfmgroup.com/FBBB/Integrates/DispatcherIn.aspx?' \
'funcid=00010013&DATE=%s' % yesterday2
ie_driver.get(url2)
# 等待frame/left加载出来
WebDriverWait(ie_driver, 30).until(EC.presence_of_element_located(
(By.XPATH, '//frame[@name="left"]')))
ie_driver.switch_to.frame('left')
time.sleep(1)
ie_driver.find_element_by_id('btnCompute').click()
# 等待计算按钮重新加载出来
WebDriverWait(ie_driver, 30).until(EC.presence_of_element_located(
(By.XPATH, '//input[@id="btnCompute"]')))
# 结束
ie_driver.quit()
except:
# 异常退出
ie_driver.quit()
wechat_auto().send_mesg(0, 'person', 5)
def get_local_driver(browser_name, headless, proxy_string):
'''
Spins up a new web browser and returns the driver.
Can also be used to spin up additional browsers for the same test.
'''
downloads_path = download_helper.get_downloads_folder()
download_helper.reset_downloads_folder()
if browser_name == constants.Browser.FIREFOX:
try:
try:
# Use Geckodriver for Firefox if it's on the PATH
profile = _create_firefox_profile(downloads_path, proxy_string)
firefox_capabilities = DesiredCapabilities.FIREFOX.copy()
firefox_capabilities['marionette'] = True
options = webdriver.FirefoxOptions()
if headless:
options.add_argument('-headless')
if LOCAL_GECKODRIVER and os.path.exists(LOCAL_GECKODRIVER):
make_driver_executable_if_not(LOCAL_GECKODRIVER)
firefox_driver = webdriver.Firefox(
firefox_profile=profile,
capabilities=firefox_capabilities,
options=options,
executable_path=LOCAL_GECKODRIVER)
else:
firefox_driver = webdriver.Firefox(
firefox_profile=profile,
capabilities=firefox_capabilities,
options=options)
except WebDriverException:
# Don't use Geckodriver: Only works for old versions of Firefox
profile = _create_firefox_profile(downloads_path, proxy_string)
firefox_capabilities = DesiredCapabilities.FIREFOX.copy()
firefox_capabilities['marionette'] = False
firefox_driver = webdriver.Firefox(
firefox_profile=profile, capabilities=firefox_capabilities)
return firefox_driver
except Exception as e:
if headless:
raise Exception(e)
return webdriver.Firefox()
elif browser_name == constants.Browser.INTERNET_EXPLORER:
if not IS_WINDOWS:
raise Exception(
"IE Browser is for Windows-based operating systems only!")
from selenium.webdriver.ie.options import Options
ie_options = Options()
ie_options.ignore_protected_mode_settings = False
ie_options.ignore_zoom_level = True
ie_options.require_window_focus = False
ie_options.native_events = True
ie_options.full_page_screenshot = True
ie_options.persistent_hover = True
ie_capabilities = ie_options.to_capabilities()
if LOCAL_IEDRIVER and os.path.exists(LOCAL_IEDRIVER):
make_driver_executable_if_not(LOCAL_IEDRIVER)
return webdriver.Ie(capabilities=ie_capabilities,
executable_path=LOCAL_IEDRIVER)
else:
return webdriver.Ie(capabilities=ie_capabilities)
elif browser_name == constants.Browser.EDGE:
if not IS_WINDOWS:
raise Exception(
"Edge Browser is for Windows-based operating systems only!")
edge_capabilities = DesiredCapabilities.EDGE.copy()
if LOCAL_EDGEDRIVER and os.path.exists(LOCAL_EDGEDRIVER):
make_driver_executable_if_not(LOCAL_EDGEDRIVER)
return webdriver.Edge(capabilities=edge_capabilities,
executable_path=LOCAL_EDGEDRIVER)
else:
return webdriver.Edge(capabilities=edge_capabilities)
elif browser_name == constants.Browser.SAFARI:
return webdriver.Safari()
elif browser_name == constants.Browser.OPERA:
if LOCAL_OPERADRIVER and os.path.exists(LOCAL_OPERADRIVER):
make_driver_executable_if_not(LOCAL_OPERADRIVER)
return webdriver.Opera(executable_path=LOCAL_OPERADRIVER)
else:
return webdriver.Opera()
elif browser_name == constants.Browser.PHANTOM_JS:
with warnings.catch_warnings():
# Ignore "PhantomJS has been deprecated" UserWarning
warnings.simplefilter("ignore", category=UserWarning)
return webdriver.PhantomJS()
elif browser_name == constants.Browser.GOOGLE_CHROME:
try:
chrome_options = _set_chrome_options(downloads_path, proxy_string)
if headless:
chrome_options.add_argument("--headless")
chrome_options.add_argument("--disable-gpu")
chrome_options.add_argument("--no-sandbox")
if LOCAL_CHROMEDRIVER and os.path.exists(LOCAL_CHROMEDRIVER):
make_driver_executable_if_not(LOCAL_CHROMEDRIVER)
return webdriver.Chrome(executable_path=LOCAL_CHROMEDRIVER,
options=chrome_options)
else:
return webdriver.Chrome(options=chrome_options)
except Exception as e:
if headless:
raise Exception(e)
if LOCAL_CHROMEDRIVER and os.path.exists(LOCAL_CHROMEDRIVER):
make_driver_executable_if_not(LOCAL_CHROMEDRIVER)
return webdriver.Chrome(executable_path=LOCAL_CHROMEDRIVER)
else:
return webdriver.Chrome()
def get_local_driver(browser_name, headless, servername, proxy_string,
proxy_auth, proxy_user, proxy_pass, user_agent,
disable_csp, enable_sync, no_sandbox, disable_gpu,
incognito, guest_mode, devtools, user_data_dir,
extension_zip, extension_dir, mobile_emulator,
device_width, device_height, device_pixel_ratio):
'''
Spins up a new web browser and returns the driver.
Can also be used to spin up additional browsers for the same test.
'''
downloads_path = download_helper.get_downloads_folder()
download_helper.reset_downloads_folder()
if browser_name == constants.Browser.FIREFOX:
try:
try:
# Use Geckodriver for Firefox if it's on the PATH
profile = _create_firefox_profile(downloads_path, proxy_string,
user_agent, disable_csp)
firefox_capabilities = DesiredCapabilities.FIREFOX.copy()
firefox_capabilities['marionette'] = True
options = webdriver.FirefoxOptions()
if headless:
options.add_argument('-headless')
firefox_capabilities['moz:firefoxOptions'] = ({
'args': ['-headless']
})
if LOCAL_GECKODRIVER and os.path.exists(LOCAL_GECKODRIVER):
try:
make_driver_executable_if_not(LOCAL_GECKODRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make geckodriver"
" executable: %s" % e)
elif not is_geckodriver_on_path():
args = " ".join(sys.argv)
if not ("-n" in sys.argv or "-n=" in args or args == "-c"):
# (Not multithreaded)
from seleniumbase.console_scripts import sb_install
sys_args = sys.argv # Save a copy of current sys args
print("\nWarning: geckodriver not found!"
" Installing now:")
try:
sb_install.main(override="geckodriver")
except Exception as e:
print("\nWarning: Could not install geckodriver: "
"%s" % e)
sys.argv = sys_args # Put back the original sys args
if "linux" in PLATFORM or not headless:
firefox_driver = webdriver.Firefox(
firefox_profile=profile,
capabilities=firefox_capabilities)
else:
firefox_driver = webdriver.Firefox(
firefox_profile=profile,
capabilities=firefox_capabilities,
options=options)
except Exception:
profile = _create_firefox_profile(downloads_path, proxy_string,
user_agent, disable_csp)
firefox_capabilities = DesiredCapabilities.FIREFOX.copy()
firefox_driver = webdriver.Firefox(
firefox_profile=profile, capabilities=firefox_capabilities)
return firefox_driver
except Exception as e:
if headless:
raise Exception(e)
return webdriver.Firefox()
elif browser_name == constants.Browser.INTERNET_EXPLORER:
if not IS_WINDOWS:
raise Exception(
"IE Browser is for Windows-based operating systems only!")
from selenium.webdriver.ie.options import Options
ie_options = Options()
ie_options.ignore_protected_mode_settings = False
ie_options.ignore_zoom_level = True
ie_options.require_window_focus = False
ie_options.native_events = True
ie_options.full_page_screenshot = True
ie_options.persistent_hover = True
ie_capabilities = ie_options.to_capabilities()
if LOCAL_IEDRIVER and os.path.exists(LOCAL_IEDRIVER):
try:
make_driver_executable_if_not(LOCAL_IEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make iedriver"
" executable: %s" % e)
return webdriver.Ie(capabilities=ie_capabilities)
elif browser_name == constants.Browser.EDGE:
try:
chrome_options = _set_chrome_options(
downloads_path, headless, proxy_string, proxy_auth, proxy_user,
proxy_pass, user_agent, disable_csp, enable_sync, no_sandbox,
disable_gpu, incognito, guest_mode, devtools, user_data_dir,
extension_zip, extension_dir, servername, mobile_emulator,
device_width, device_height, device_pixel_ratio)
if LOCAL_EDGEDRIVER and os.path.exists(LOCAL_EDGEDRIVER):
try:
make_driver_executable_if_not(LOCAL_EDGEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make edgedriver"
" executable: %s" % e)
elif not is_edgedriver_on_path():
args = " ".join(sys.argv)
if not ("-n" in sys.argv or "-n=" in args or args == "-c"):
# (Not multithreaded)
from seleniumbase.console_scripts import sb_install
sys_args = sys.argv # Save a copy of current sys args
print("\nWarning: msedgedriver not found. Installing now:")
sb_install.main(override="edgedriver")
sys.argv = sys_args # Put back the original sys args
return webdriver.Chrome(executable_path=LOCAL_EDGEDRIVER,
options=chrome_options)
except Exception as e:
if headless:
raise Exception(e)
if LOCAL_EDGEDRIVER and os.path.exists(LOCAL_EDGEDRIVER):
try:
make_driver_executable_if_not(LOCAL_EDGEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make edgedriver"
" executable: %s" % e)
return webdriver.Chrome(executable_path=LOCAL_EDGEDRIVER)
elif browser_name == constants.Browser.SAFARI:
arg_join = " ".join(sys.argv)
if ("-n" in sys.argv) or ("-n=" in arg_join) or (arg_join == "-c"):
# Skip if multithreaded
raise Exception("Can't run Safari tests in multi-threaded mode!")
return webdriver.Safari()
elif browser_name == constants.Browser.OPERA:
if LOCAL_OPERADRIVER and os.path.exists(LOCAL_OPERADRIVER):
try:
make_driver_executable_if_not(LOCAL_OPERADRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make operadriver"
" executable: %s" % e)
return webdriver.Opera()
elif browser_name == constants.Browser.PHANTOM_JS:
with warnings.catch_warnings():
# Ignore "PhantomJS has been deprecated" UserWarning
warnings.simplefilter("ignore", category=UserWarning)
return webdriver.PhantomJS()
elif browser_name == constants.Browser.GOOGLE_CHROME:
try:
chrome_options = _set_chrome_options(
downloads_path, headless, proxy_string, proxy_auth, proxy_user,
proxy_pass, user_agent, disable_csp, enable_sync, no_sandbox,
disable_gpu, incognito, guest_mode, devtools, user_data_dir,
extension_zip, extension_dir, servername, mobile_emulator,
device_width, device_height, device_pixel_ratio)
if LOCAL_CHROMEDRIVER and os.path.exists(LOCAL_CHROMEDRIVER):
try:
make_driver_executable_if_not(LOCAL_CHROMEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make chromedriver"
" executable: %s" % e)
elif not is_chromedriver_on_path():
args = " ".join(sys.argv)
if not ("-n" in sys.argv or "-n=" in args or args == "-c"):
# (Not multithreaded)
from seleniumbase.console_scripts import sb_install
sys_args = sys.argv # Save a copy of current sys args
print("\nWarning: chromedriver not found. Installing now:")
sb_install.main(override="chromedriver")
sys.argv = sys_args # Put back the original sys args
return webdriver.Chrome(options=chrome_options)
except Exception as e:
if headless:
raise Exception(e)
if LOCAL_CHROMEDRIVER and os.path.exists(LOCAL_CHROMEDRIVER):
try:
make_driver_executable_if_not(LOCAL_CHROMEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make chromedriver"
" executable: %s" % e)
return webdriver.Chrome()
else:
raise Exception("%s is not a valid browser option for this system!" %
browser_name)
def get_local_driver(
browser_name, headless, locale_code, servername,
proxy_string, proxy_auth, proxy_user, proxy_pass, user_agent,
disable_csp, enable_ws, enable_sync, use_auto_ext, no_sandbox,
disable_gpu, incognito, guest_mode, devtools, swiftshader,
block_images, user_data_dir, extension_zip, extension_dir,
mobile_emulator, device_width, device_height, device_pixel_ratio):
'''
Spins up a new web browser and returns the driver.
Can also be used to spin up additional browsers for the same test.
'''
downloads_path = download_helper.get_downloads_folder()
download_helper.reset_downloads_folder()
if browser_name == constants.Browser.FIREFOX:
try:
try:
# Use Geckodriver for Firefox if it's on the PATH
profile = _create_firefox_profile(
downloads_path, locale_code,
proxy_string, user_agent, disable_csp)
firefox_capabilities = DesiredCapabilities.FIREFOX.copy()
firefox_capabilities['marionette'] = True
options = webdriver.FirefoxOptions()
if headless:
options.add_argument('-headless')
firefox_capabilities['moz:firefoxOptions'] = (
{'args': ['-headless']})
if LOCAL_GECKODRIVER and os.path.exists(LOCAL_GECKODRIVER):
try:
make_driver_executable_if_not(LOCAL_GECKODRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make geckodriver"
" executable: %s" % e)
elif not is_geckodriver_on_path():
args = " ".join(sys.argv)
if not ("-n" in sys.argv or "-n=" in args or args == "-c"):
# (Not multithreaded)
from seleniumbase.console_scripts import sb_install
sys_args = sys.argv # Save a copy of current sys args
print("\nWarning: geckodriver not found!"
" Installing now:")
try:
sb_install.main(override="geckodriver")
except Exception as e:
print("\nWarning: Could not install geckodriver: "
"%s" % e)
sys.argv = sys_args # Put back the original sys args
if "linux" in PLATFORM or not headless:
firefox_driver = webdriver.Firefox(
firefox_profile=profile,
capabilities=firefox_capabilities)
else:
firefox_driver = webdriver.Firefox(
firefox_profile=profile,
capabilities=firefox_capabilities,
options=options)
except Exception:
profile = _create_firefox_profile(
downloads_path, locale_code,
proxy_string, user_agent, disable_csp)
firefox_capabilities = DesiredCapabilities.FIREFOX.copy()
firefox_driver = webdriver.Firefox(
firefox_profile=profile,
capabilities=firefox_capabilities)
return firefox_driver
except Exception as e:
if headless:
raise Exception(e)
return webdriver.Firefox()
elif browser_name == constants.Browser.INTERNET_EXPLORER:
if not IS_WINDOWS:
raise Exception(
"IE Browser is for Windows-based operating systems only!")
from selenium.webdriver.ie.options import Options
ie_options = Options()
ie_options.ignore_protected_mode_settings = False
ie_options.ignore_zoom_level = True
ie_options.require_window_focus = False
ie_options.native_events = True
ie_options.full_page_screenshot = True
ie_options.persistent_hover = True
ie_capabilities = ie_options.to_capabilities()
if LOCAL_IEDRIVER and os.path.exists(LOCAL_IEDRIVER):
try:
make_driver_executable_if_not(LOCAL_IEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make iedriver"
" executable: %s" % e)
return webdriver.Ie(capabilities=ie_capabilities)
elif browser_name == constants.Browser.EDGE:
try:
chrome_options = _set_chrome_options(
browser_name, downloads_path, headless, locale_code,
proxy_string, proxy_auth, proxy_user, proxy_pass, user_agent,
disable_csp, enable_ws, enable_sync, use_auto_ext,
no_sandbox, disable_gpu, incognito, guest_mode, devtools,
swiftshader, block_images, user_data_dir,
extension_zip, extension_dir, servername,
mobile_emulator, device_width, device_height,
device_pixel_ratio)
if LOCAL_EDGEDRIVER and os.path.exists(LOCAL_EDGEDRIVER):
try:
make_driver_executable_if_not(LOCAL_EDGEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make edgedriver"
" executable: %s" % e)
elif not is_edgedriver_on_path():
args = " ".join(sys.argv)
if not ("-n" in sys.argv or "-n=" in args or args == "-c"):
# (Not multithreaded)
from seleniumbase.console_scripts import sb_install
sys_args = sys.argv # Save a copy of current sys args
print("\nWarning: msedgedriver not found. Installing now:")
sb_install.main(override="edgedriver")
sys.argv = sys_args # Put back the original sys args
# For Microsoft Edge (Chromium) version 79 or lower
return webdriver.Chrome(executable_path=LOCAL_EDGEDRIVER,
options=chrome_options)
except Exception:
# For Microsoft Edge (Chromium) version 80 or higher
from msedge.selenium_tools import Edge, EdgeOptions
if LOCAL_EDGEDRIVER and os.path.exists(LOCAL_EDGEDRIVER):
try:
make_driver_executable_if_not(LOCAL_EDGEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make edgedriver"
" executable: %s" % e)
edge_options = EdgeOptions()
edge_options.use_chromium = True
prefs = {
"download.default_directory": downloads_path,
"local_discovery.notifications_enabled": False,
"credentials_enable_service": False,
"download.prompt_for_download": False,
"download.directory_upgrade": True,
"safebrowsing.enabled": False,
"safebrowsing.disable_download_protection": True,
"profile": {
"password_manager_enabled": False,
"default_content_setting_values.automatic_downloads": 1,
"managed_default_content_settings.automatic_downloads": 1,
"default_content_settings.popups": 0,
"managed_default_content_settings.popups": 0
}
}
if locale_code:
prefs["intl.accept_languages"] = locale_code
if block_images:
prefs["profile.managed_default_content_settings.images"] = 2
edge_options.add_experimental_option("prefs", prefs)
edge_options.add_experimental_option("w3c", True)
edge_options.add_experimental_option(
"useAutomationExtension", False)
edge_options.add_experimental_option(
"excludeSwitches", ["enable-automation", "enable-logging"])
if guest_mode:
edge_options.add_argument("--guest")
if headless:
edge_options.add_argument("--headless")
if mobile_emulator:
emulator_settings = {}
device_metrics = {}
if type(device_width) is int and (
type(device_height) is int and (
type(device_pixel_ratio) is int)):
device_metrics["width"] = device_width
device_metrics["height"] = device_height
device_metrics["pixelRatio"] = device_pixel_ratio
else:
device_metrics["width"] = 411
device_metrics["height"] = 731
device_metrics["pixelRatio"] = 3
emulator_settings["deviceMetrics"] = device_metrics
if user_agent:
emulator_settings["userAgent"] = user_agent
edge_options.add_experimental_option(
"mobileEmulation", emulator_settings)
edge_options.add_argument("--enable-sync")
edge_options.add_argument("--disable-infobars")
edge_options.add_argument("--disable-save-password-bubble")
edge_options.add_argument("--disable-single-click-autofill")
edge_options.add_argument(
"--disable-autofill-keyboard-accessory-view[8]")
edge_options.add_argument("--disable-translate")
if not enable_ws:
edge_options.add_argument("--disable-web-security")
edge_options.add_argument("--homepage=about:blank")
edge_options.add_argument("--dns-prefetch-disable")
edge_options.add_argument("--dom-automation")
edge_options.add_argument("--disable-hang-monitor")
edge_options.add_argument("--disable-prompt-on-repost")
if proxy_string:
edge_options.add_argument('--proxy-server=%s' % proxy_string)
edge_options.add_argument("--test-type")
edge_options.add_argument("--log-level=3")
edge_options.add_argument("--no-first-run")
edge_options.add_argument("--ignore-certificate-errors")
if devtools and not headless:
edge_options.add_argument("--auto-open-devtools-for-tabs")
edge_options.add_argument("--allow-file-access-from-files")
edge_options.add_argument("--allow-insecure-localhost")
edge_options.add_argument("--allow-running-insecure-content")
if user_agent:
edge_options.add_argument("--user-agent=%s" % user_agent)
edge_options.add_argument("--no-sandbox")
if swiftshader:
edge_options.add_argument("--use-gl=swiftshader")
else:
edge_options.add_argument("--disable-gpu")
if "linux" in PLATFORM:
edge_options.add_argument("--disable-dev-shm-usage")
capabilities = edge_options.to_capabilities()
capabilities["platform"] = ''
return Edge(
executable_path=LOCAL_EDGEDRIVER, capabilities=capabilities)
elif browser_name == constants.Browser.SAFARI:
arg_join = " ".join(sys.argv)
if ("-n" in sys.argv) or ("-n=" in arg_join) or (arg_join == "-c"):
# Skip if multithreaded
raise Exception("Can't run Safari tests in multi-threaded mode!")
safari_capabilities = _set_safari_capabilities()
return webdriver.Safari(desired_capabilities=safari_capabilities)
elif browser_name == constants.Browser.OPERA:
try:
if LOCAL_OPERADRIVER and os.path.exists(LOCAL_OPERADRIVER):
try:
make_driver_executable_if_not(LOCAL_OPERADRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make operadriver"
" executable: %s" % e)
opera_options = _set_chrome_options(
browser_name, downloads_path, headless, locale_code,
proxy_string, proxy_auth, proxy_user, proxy_pass, user_agent,
disable_csp, enable_ws, enable_sync, use_auto_ext,
no_sandbox, disable_gpu, incognito, guest_mode, devtools,
swiftshader, block_images, user_data_dir, extension_zip,
extension_dir, servername, mobile_emulator,
device_width, device_height, device_pixel_ratio)
opera_options.headless = False # No support for headless Opera
return webdriver.Opera(options=opera_options)
except Exception:
return webdriver.Opera()
elif browser_name == constants.Browser.PHANTOM_JS:
with warnings.catch_warnings():
# Ignore "PhantomJS has been deprecated" UserWarning
warnings.simplefilter("ignore", category=UserWarning)
return webdriver.PhantomJS()
elif browser_name == constants.Browser.GOOGLE_CHROME:
try:
chrome_options = _set_chrome_options(
browser_name, downloads_path, headless, locale_code,
proxy_string, proxy_auth, proxy_user, proxy_pass, user_agent,
disable_csp, enable_ws, enable_sync, use_auto_ext,
no_sandbox, disable_gpu, incognito, guest_mode, devtools,
swiftshader, block_images, user_data_dir, extension_zip,
extension_dir, servername, mobile_emulator,
device_width, device_height, device_pixel_ratio)
if LOCAL_CHROMEDRIVER and os.path.exists(LOCAL_CHROMEDRIVER):
try:
make_driver_executable_if_not(LOCAL_CHROMEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make chromedriver"
" executable: %s" % e)
elif not is_chromedriver_on_path():
args = " ".join(sys.argv)
if not ("-n" in sys.argv or "-n=" in args or args == "-c"):
# (Not multithreaded)
from seleniumbase.console_scripts import sb_install
sys_args = sys.argv # Save a copy of current sys args
print("\nWarning: chromedriver not found. Installing now:")
sb_install.main(override="chromedriver")
sys.argv = sys_args # Put back the original sys args
if not headless or "linux" not in PLATFORM:
return webdriver.Chrome(options=chrome_options)
else: # Running headless on Linux
try:
return webdriver.Chrome(options=chrome_options)
except Exception:
# Use the virtual display on Linux during headless errors
logging.debug("\nWarning: Chrome failed to launch in"
" headless mode. Attempting to use the"
" SeleniumBase virtual display on Linux...")
chrome_options.headless = False
return webdriver.Chrome(options=chrome_options)
except Exception as e:
if headless:
raise Exception(e)
if LOCAL_CHROMEDRIVER and os.path.exists(LOCAL_CHROMEDRIVER):
try:
make_driver_executable_if_not(LOCAL_CHROMEDRIVER)
except Exception as e:
logging.debug("\nWarning: Could not make chromedriver"
" executable: %s" % e)
return webdriver.Chrome()
else:
raise Exception(
"%s is not a valid browser option for this system!" % browser_name)
def init_driver(n):
common_tools.save_log(statement.start_to_init_browser)
chrome_capabilities = {
'browserName': 'chrome',
'chromeOptions': {
'useAutomationExtension': False,
'forceDevToolsScreenshot': True,
'args': ['--disable-infobars']
# 'args': ['--start-maximized', '--disable-infobars']
}
}
ie11_capabilities = {
'browserName': 'internet explorer',
'ie_options': {
'nativeEvents': False,
'unexpectedAlertBehaviour': True,
'ignoreProtectedModeSettings': True,
'disable-popup-blocking': True,
'enablePersistentHover': True,
'ignoreZoomSetting': True,
}
}
ie11_opts = Options()
ie11_opts.ignore_protected_mode_settings = True
ie11_opts.ignore_zoom_level = True
ie11_opts.require_window_focus = False
ie11_opts.native_events = False
ie11_opts.persistent_hover = True
# INTRODUCE_FLAKINESS_BY_IGNORING_SECURITY_DOMAINS
ie11_cap = DesiredCapabilities.INTERNETEXPLORER.copy()
ie11_cap["ignoreProtectedModeSettings"] = True
# ie11_cap["IntroduceInstabilityByIgnoringProtectedModeSettings"] = True
ie11_cap["nativeEvents"] = False
# ie11_cap["browserFocus"] = False
ie11_cap["ignoreZoomSetting"] = True
ie11_cap["requireWindowFocus"] = False
# ie11_cap["INTRODUCE_FLAKINESS_BY_IGNORING_SECURITY_DOMAINS"] = True
if (n <= 40):
driver_fire = webdriver.Edge()
browser = 0
elif (n <= 80):
browser = 1
profile = webdriver.FirefoxProfile()
profile.set_preference('browser.download.dir', 'c:\\')
profile.set_preference('browser.download.folderList', 2)
profile.set_preference('browser.download.manager.showWhenStarting', False)
profile.set_preference('browser.helperApps.neverAsk.saveToDisk', 'application/pdf')
driver_fire = webdriver.Firefox(timeout=settings.browser_launch_timeout, firefox_profile=profile)
elif (n <=120):
browser = 2
driver_fire = webdriver.Chrome(desired_capabilities=chrome_capabilities)
# elif (n <= 120):
# browser = 3
# driver_fire = webdriver.Ie(capabilities=ie11_capabilities)
# driver_fire = webdriver.Ie(ie_options=ie11_opts)
# # driver_fire = webdriver.Ie(capabilities=ie11_cap)
# # driver_fire = webdriver.Ie(desired_capabilities=ie11_cap)
# browser = 3
driver = SmartEventFiringWebDriver(driver=driver_fire,
event_listener=listener.SMART_Listener())
return driver, browser
from selenium import webdriver
from selenium.webdriver.ie.options import Options
from selenium.webdriver.common.keys import Keys
import time
caps = webdriver.DesiredCapabilities.INTERNETEXPLORER # Test Comment
caps["IgnoreProtectedModeSettings"] = True """Test Comment"""
caps["IgnoreZoomSetting"] = True
path="../driver/IEDriverServer.exe"
ie_options=Options()
ie_options.add_argument("--headless")
driver = webdriver.Ie(executable_path=path, desired_capabilities=caps, options=ie_options)
driver.get("https://www.google.com")
print(driver.title)
driver.find_element_by_name("q").send_keys("Automation Step by Step")
driver.find_element_by_name("btnK").send_keys(Keys.ENTER)
time.sleep(2)
print(driver.title)
driver.close()
driver.quit()
def function_driver(request):
"""
driver注入
@param request:
@return:
"""
browser = request.config.getoption("--browser")
# 用于本地启动是否开启浏览器设置，根据命令行传参，browser_opt判断，默认open
browser_opt = request.config.getoption("--browser_opt")
print("获取命令行传参：{}".format(request.config.getoption("--browser")))
type_driver = request.config.getoption("--type_driver")
# 判断是本地还是远程
if type_driver == "local":
if browser_opt == "open":
if browser == "chrome":
# 跳过非安全的https安全校验
chrome_options = CO()
chrome_options.add_argument("--ignore-certificate-errors")
driver = webdriver.Chrome(chrome_options=chrome_options)
elif browser == "firefox":
# 跳过非安全的https安全校验
profile = FP()
profile.accept_untrusted_certs = True
driver = webdriver.Firefox(firefox_profile=profile)
elif browser == "ie":
# 跳过非安全的https安全校验
capabilities = webdriver.DesiredCapabilities()
capabilities['acceptSslCerts'] = True
driver = webdriver.Ie(capabilities=capabilities)
else:
logging.info("发送错误浏览器参数：{}".format(browser))
else:
if browser == "chrome":
# 不开启浏览器窗口，后台运行测试代码
chrome_options = CO()
chrome_options.add_argument('--headless')
# 跳过非安全的https安全校验
chrome_options.add_argument('--ignore-certificate-errors')
driver = webdriver.Chrome(chrome_options=chrome_options)
elif browser == "firefox":
# 不开启浏览器窗口，后台运行测试代码
firefox_options = FO()
firefox_options.add_argument('--headless')
# 跳过非安全的https安全校验
profile = FP()
profile.accept_untrusted_certs = True
driver = webdriver.Firefox(firefox_options=firefox_options, firefox_profile=profile)
elif browser == "ie":
# 不开启浏览器窗口，后台运行测试代码
ie_options = IEO()
ie_options.add_argument('--headless')
# 跳过非安全的https安全校验
capabilities = webdriver.DesiredCapabilities()
capabilities['acceptSslCerts'] = True
driver = webdriver.Ie(ie_options=ie_options, capabilities=capabilities)
else:
logging.info("发送错误浏览器参数：{}".format(browser))
yield driver
# driver.close()
driver.quit()
elif type_driver == "remote":
driver = Remote(command_executor=selenium_config["selenium_config"]["selenium_hub_url"],
desired_capabilities={'platform': 'ANY', 'browserName': browser, 'version': '',
'javascriptEnabled': True})
yield driver
# driver.close()
driver.quit()
else:
logging.error("driver参数传递错误，请检查参数：{}".format(type_driver))
def get_local_driver(
browser_name, headless, proxy_string, proxy_auth,
proxy_user, proxy_pass, user_agent, disable_csp):
'''
Spins up a new web browser and returns the driver.
Can also be used to spin up additional browsers for the same test.
'''
downloads_path = download_helper.get_downloads_folder()
download_helper.reset_downloads_folder()
if browser_name == constants.Browser.FIREFOX:
try:
try:
# Use Geckodriver for Firefox if it's on the PATH
profile = _create_firefox_profile(
downloads_path, proxy_string, user_agent, disable_csp)
firefox_capabilities = DesiredCapabilities.FIREFOX.copy()
firefox_capabilities['marionette'] = True
options = webdriver.FirefoxOptions()
if headless:
options.add_argument('-headless')
if LOCAL_GECKODRIVER and os.path.exists(LOCAL_GECKODRIVER):
make_driver_executable_if_not(LOCAL_GECKODRIVER)
firefox_driver = webdriver.Firefox(
firefox_profile=profile,
capabilities=firefox_capabilities,
options=options,
executable_path=LOCAL_GECKODRIVER)
else:
firefox_driver = webdriver.Firefox(
firefox_profile=profile,
capabilities=firefox_capabilities,
options=options)
except WebDriverException:
# Don't use Geckodriver: Only works for old versions of Firefox
profile = _create_firefox_profile(
downloads_path, proxy_string, user_agent, disable_csp)
firefox_capabilities = DesiredCapabilities.FIREFOX.copy()
firefox_capabilities['marionette'] = False
firefox_driver = webdriver.Firefox(
firefox_profile=profile, capabilities=firefox_capabilities)
return firefox_driver
except Exception as e:
if headless:
raise Exception(e)
return webdriver.Firefox()
elif browser_name == constants.Browser.INTERNET_EXPLORER:
if not IS_WINDOWS:
raise Exception(
"IE Browser is for Windows-based operating systems only!")
from selenium.webdriver.ie.options import Options
ie_options = Options()
ie_options.ignore_protected_mode_settings = False
ie_options.ignore_zoom_level = True
ie_options.require_window_focus = False
ie_options.native_events = True
ie_options.full_page_screenshot = True
ie_options.persistent_hover = True
ie_capabilities = ie_options.to_capabilities()
if LOCAL_IEDRIVER and os.path.exists(LOCAL_IEDRIVER):
make_driver_executable_if_not(LOCAL_IEDRIVER)
return webdriver.Ie(
capabilities=ie_capabilities,
executable_path=LOCAL_IEDRIVER)
else:
return webdriver.Ie(capabilities=ie_capabilities)
elif browser_name == constants.Browser.EDGE:
if not IS_WINDOWS:
raise Exception(
"Edge Browser is for Windows-based operating systems only!")
edge_capabilities = DesiredCapabilities.EDGE.copy()
if LOCAL_EDGEDRIVER and os.path.exists(LOCAL_EDGEDRIVER):
make_driver_executable_if_not(LOCAL_EDGEDRIVER)
return webdriver.Edge(
capabilities=edge_capabilities,
executable_path=LOCAL_EDGEDRIVER)
else:
return webdriver.Edge(capabilities=edge_capabilities)
elif browser_name == constants.Browser.SAFARI:
return webdriver.Safari()
elif browser_name == constants.Browser.OPERA:
if LOCAL_OPERADRIVER and os.path.exists(LOCAL_OPERADRIVER):
make_driver_executable_if_not(LOCAL_OPERADRIVER)
return webdriver.Opera(executable_path=LOCAL_OPERADRIVER)
else:
return webdriver.Opera()
elif browser_name == constants.Browser.PHANTOM_JS:
with warnings.catch_warnings():
# Ignore "PhantomJS has been deprecated" UserWarning
warnings.simplefilter("ignore", category=UserWarning)
return webdriver.PhantomJS()
elif browser_name == constants.Browser.GOOGLE_CHROME:
try:
chrome_options = _set_chrome_options(
downloads_path, headless, proxy_string, proxy_auth,
proxy_user, proxy_pass, user_agent, disable_csp)
if headless:
# Headless Chrome doesn't support extensions, which are
# required when using a proxy server that has authentication.
# Instead, base_case.py will use PyVirtualDisplay when not
# using Chrome's built-in headless mode. See link for details:
# https://bugs.chromium.org/p/chromium/issues/detail?id=706008
if not proxy_auth:
chrome_options.add_argument("--headless")
chrome_options.add_argument("--disable-gpu")
chrome_options.add_argument("--no-sandbox")
if LOCAL_CHROMEDRIVER and os.path.exists(LOCAL_CHROMEDRIVER):
make_driver_executable_if_not(LOCAL_CHROMEDRIVER)
return webdriver.Chrome(
executable_path=LOCAL_CHROMEDRIVER, options=chrome_options)
else:
return webdriver.Chrome(options=chrome_options)
except Exception as e:
if headless:
raise Exception(e)
if LOCAL_CHROMEDRIVER and os.path.exists(LOCAL_CHROMEDRIVER):
make_driver_executable_if_not(LOCAL_CHROMEDRIVER)
return webdriver.Chrome(executable_path=LOCAL_CHROMEDRIVER)
else:
return webdriver.Chrome()
else:
raise Exception(
"%s is not a valid browser option for this system!" % browser_name)
