def driver(request):
browser = request.config.getoption("--browser")
wd = None
if browser == 'chrome':
options = webdriver.ChromeOptions()
options.add_argument('--headless')
options.add_argument('window-size=1920x935')
wd = webdriver.Chrome(options=options)
wd.get(request.config.getoption("--url"))
if browser == 'firefox':
options = webdriver.FirefoxOptions()
options.add_argument('--headless')
options.add_argument('window-size=1920x935')
wd = webdriver.Firefox(options=options)
wd.get(request.config.getoption("--url"))
if browser == 'ie':
options = webdriver.IeOptions()
options.add_argument('--headless')
options.add_argument('window-size=1920x935')
options = webdriver.IeOptions(options=options)
browser.get(request.config.getoption("--url"))
else:
print('Unsupported browser!')
yield wd
if wd is not None:
wd.close()
def browser(request):
browser = request.config.getoption("--browser")
wd = None
if browser == 'chrome':
options = webdriver.ChromeOptions()
options.add_argument('--headless')
options.add_argument('--start-maximized')
options.add_experimental_option('w3c', False)
caps = DesiredCapabilities.CHROME
caps['loggingPrefs'] = {'browser': 'INFO'}
wd = EventFiringWebDriver(
webdriver.Chrome(executable_path='./chromedriver',
desired_capabilities=caps,
options=options), MyListener())
wd.implicitly_wait(request.config.getoption("--wait"))
wd.get(request.config.getoption("--url"))
elif browser == 'firefox':
options = webdriver.FirefoxOptions()
options.add_argument('--start-maximized')
options.add_argument('--start-maximized')
options.add_experimental_option('w3c', False)
caps = DesiredCapabilities.FIREFOX
caps['loggingPrefs'] = {'browser': 'INFO'}
wd = EventFiringWebDriver(
webdriver.Firefox(desired_capabilities=caps, options=options),
MyListener())
wd.implicitly_wait(request.config.getoption("--wait"))
wd.get(request.config.getoption("--url"))
elif browser == 'ie':
options = webdriver.IeOptions()
# options.add_argument('--headless')
options.add_argument('window-size=1920x935')
wd = webdriver.IeOptions(options=options)
wd.implicitly_wait(request.config.getoption("--wait"))
wd.get(request.config.getoption("--url"))
else:
print('Unsupported browser!')
failed_before = request.session.testsfailed
yield wd
if request.session.testsfailed != failed_before:
try:
allure.attach(wd.get_screenshot_as_png(),
name=request.function.__name__,
attachment_type=allure.attachment_type.PNG)
except:
pass # just ignore
# Close browser window:
request.addfinalizer(wd.close)
def __init__(self,webbroser=WEBBROSER,downloadpath=FILE,time=25):
# 运行脚本时不用打开浏览器
# options.add_argument("--headless")
# 要加多下面两个设置，如果不加，运行时有元素会定位不到,但目录订单导入会有问题，没有上传到附件
# options.add_argument('window-size=1920x1080')
# options.add_argument('--start-maximized')
# 定义浏览器
if webbroser == 'chrome':
# 隐性等待，要网页加载完成，隐性等待对整个driver的周期都起作用，所以只要设置一次即可
options = webdriver.ChromeOptions()
# 浏览器默认下载路径
prefs = {'profile.default_content_settings.popups': 0, 'download.default_directory': downloadpath}
options.add_experimental_option('prefs', prefs)
# 指定浏览器驱动的目的是能正确启动浏览器 ，如果不指定，项目执行时可能找不到驱动
self.driver = webdriver.Chrome(executable_path=r'C:\Users\Administrator\AppData\Local\Google\Chrome\Application\chromedriver.exe', chrome_options=options)
# 65服务器
# self.driver = webdriver.Chrome(executable_path=r'E:\software\Python3.8.3\UiAuto\common\chromedriver.exe',
# chrome_options=options)
elif webbroser == 'ie':
option = webdriver.IeOptions()
option.add_argument('headless')
self.driver = webdriver.Ie(ie_options=option)
# self.driver=webdriver.Ie()
elif webbroser == 'firefox':
option = webdriver.FirefoxOptions()
# option.add_argument('headless')
self.driver = webdriver.Firefox(executable_path=r'E:\software\Python3.8.3\UiAuto\bin\geckodriver.exe',firefox_options=option)
else:
print('请输入谷歌、火狐、IE中的一种！')
Mylog().my_log().info('请输入谷歌、火狐、IE中的一种！')
def open(self, try_silent: bool = True) -> WebDriver:
"""Spustí a vrátí WebDriver instanci"""
# try_silent = False # Pouze pro debugování
driver: WebDriver
if self.browser == Browser.CHROME:
options_chrome = webdriver.ChromeOptions()
if try_silent:
options_chrome.set_headless(True)
driver = webdriver.Chrome(options=options_chrome,
**self._builded_params)
elif self.browser == Browser.FIREFOX:
options_firefox = webdriver.FirefoxOptions()
if try_silent:
options_firefox.set_headless(True)
driver = webdriver.Firefox(options=options_firefox,
**self._builded_params)
elif self.browser == Browser.EDGE:
driver = webdriver.Edge(**self._builded_params)
elif self.browser == Browser.SAFARI:
driver = webdriver.Safari(**self._builded_params)
elif self.browser == Browser.OPERA:
driver = webdriver.Opera(**self._builded_params)
elif self.browser == Browser.IE:
options_ie = webdriver.IeOptions()
driver = webdriver.Ie(options=options_ie, **self._builded_params)
else:
raise ValueError()
return driver
def openIe():
# 加启动配置
option = webdriver.IeOptions()
option.add_argument('disable-infobars')
# 打开chrome浏览器
driver = webdriver.Ie(ie_options=option)
return driver
def __init__(self, brower):
if brower =='Chrome' or brower =='chrome' or brower =='Ch' or brower=='ch':
option = webdriver.ChromeOptions()
option.add_argument("headless")
# 禁用GPU硬件加速，防止出现BUG
option.add_argument("disable-gpu")
driver = webdriver.Chrome(executable_path=CHROME_PATH, options=option)
logger.info("启动 Chrome--Headless 浏览器")
elif brower =='firefox' or brower =='Firefox' or brower =='f' or brower =='F':
option = webdriver.FirefoxOptions()
option.add_argument("headless")
# 禁用GPU硬件加速，防止出现BUG
option.add_argument("disable-gpu")
driver = webdriver.Firefox(executable_path=FIREFOX_PATH, options=option)
logger.info("启动 Firefox-Headless 浏览器")
elif brower =='Ie' or brower =='ie' or brower =='i' or brower=='I':
option = webdriver.IeOptions()
option.add_argument("headless")
# 禁用GPU硬件加速，防止出现BUG
option.add_argument("disable-gpu")
driver = webdriver.Ie(options=option)
logger.info("启动 IE-Headless 浏览器")
else:
raise NameError("只能输入firefox,Ie,Chrome")
logger.error(brower)
self.driver = driver
def launch_app(browser_name, url):
global driver
if browser_name == "chrome":
chromeoptions = webdriver.ChromeOptions()
chromeoptions.add_argument("start-maximized")
chromeoptions.add_argument("disable-notifications")
chromeoptions.add_argument("--disable-infobars")
chromeoptions.add_argument("--ignore-certificate-errors")
chromeoptions.add_argument("--disable-extensions")
driver = webdriver.Chrome(executable_path="./drivers/chromedriver.exe",
options=chromeoptions)
elif browser_name == "firefox":
# firefoxoptions=webdriver.FirefoxOptions()
# firefoxoptions.add_argument("start-maximized")
# firefoxoptions.add_argument("disable-notifications")
# firefoxoptions.add_argument("--disable-infobars")
# firefoxoptions.add_argument("--ignore-certificate-errors")
# firefoxoptions.add_argument("--disable-extensions")
driver = webdriver.Firefox(executable_path="./drivers/geckodriver.exe")
elif browser_name == "ie":
ieoptions = webdriver.IeOptions()
ieoptions.add_argument("start-maximized")
ieoptions.add_argument("disable-notifications")
ieoptions.add_argument("--disable-infobars")
ieoptions.add_argument("--ignore-certificate-errors")
ieoptions.add_argument("--disable-extensions")
driver = webdriver.Ie(executable_path="./drivers/IEDriverServer.exe",
options=ieoptions)
else:
print("invalid browser name")
driver.get(url)
def getWebDriverInstance(self):
"""
Get WebDriver Instance based on the browser configuration
Returns:
'WebDriver Instance'
"""
baseURL = "https://letskodeit.teachable.com/"
# Set chrome driver
if self.browser == "chrome":
driver = webdriver.Chrome(
executable_path=r'C:\SeleniumStandalone\fg.exe')
driver = webdriver.IeOptions()
elif self.browser == "firefox":
driver = webdriver.Firefox(
executable_path=r'C:\SeleniumStandalone\geckodriver.exe')
driver = webdriver.Firefox()
else:
driver = webdriver.Chrome(
executable_path=r'C:\SeleniumStandalone\chromedriver.exe')
driver = webdriver.Chrome()
driver.implicitly_wait(3)
driver.maximize_window()
driver.get(baseURL)
return driver
def new_browser(request):
args = request.config.getoption("--brows")
if args == "gh":
# gdd = GeckoDriverManager
# gdd.download_and_install()
option = webdriver.ChromeOptions()
# option.add_argument("--headless")
option.add_argument("--start-fullscreen")
option.add_argument('ignore-certificate-errors')
wd = webdriver.Chrome(chrome_options=option)
elif args == "ff":
# gdd = GeckoDriverManager
# gdd.download_and_install()
option = webdriver.FirefoxOptions()
# option.add_argument("--headless")
option.add_argument("--start-maximized")
option.add_argument("--kiosk")
option.accept_insecure_certs = True
wd = webdriver.Firefox(firefox_profile=option)
elif args == "ie":
# gdd = GeckoDriverManager
# gdd.download_and_install()
option = webdriver.IeOptions()
option.add_argument("--embedding")
# option.add_argument("-k")
wd = webdriver.Ie(options=option)
# yield wd
# wd.quit()
request.addfinalizer(wd.quit)
return wd
class REMOTE:
PLATFORM = platform.system().lower()
PLATFORM_OS = "windows" if PLATFORM.startswith(
'windows') else "mac" if PLATFORM.startswith('darwin') else 'linux'
PC_PLATFORM = ("windows", "mac", "linux")
MOBILE_PLATFORM = ("ios", "android")
BROWSERS = ("chrome", "firefox", "safari", "ie", "edge")
BROWSER_OPTIONS = {
'chrome': webdriver.ChromeOptions(),
'firefox': webdriver.FirefoxOptions(),
'ie': webdriver.IeOptions()
}
WEBDRIVERS = {
'chrome': webdriver.Chrome,
'firefox': webdriver.Firefox,
'ie': webdriver.Ie,
'edge': webdriver.Edge,
'safari': webdriver.Safari
}
WEBDRIVER_BIN = {
'chrome': str(PATH('WebDrivers/chromedriver.exe')),
'firefox': str(PATH('WebDrivers/geckodriver.exe')),
'ie': str(PATH('WebDrivers/IEDriverServer.exe')),
'edge': str(PATH('WebDrivers/MicrosoftWebDriver.exe')),
'safari': "",
}
DEFAULT_DRIVER = {
'chrome': "chromedriver",
'firefox': "geckodriver",
'ie': 'IEDriverServer.exe',
'edge': 'MicrosoftWebDriver.exe',
'safari': "/usr/bin/safaridriver"
}
def init_driver(browser_type, *driver_path):
if browser_type == 'edge':
if driver_path.__len__() != 0:
webdriver_path = driver_path[0]
return webdriver.Edge(executable_path=webdriver_path)
if browser_type == 'chrome':
chrome_option = webdriver.ChromeOptions()
chrome_option.add_experimental_option('excludeSwitches',
['enable-automation'])
chrome_option.add_experimental_option('useAutomationExtension', False)
chrome_option.add_experimental_option(
'prefs', {
'credentials_enable_service': False,
'profile': {
'password_manager_enabled': False
}
})
chrome_option.binary_location = 'D:/Program Files/chromium/chrome.exe'
if driver_path.__len__() != 0:
webdriver_path = driver_path[0]
return webdriver.Chrome(executable_path=webdriver_path,
chrome_options=chrome_option)
if browser_type == 'ie':
ie_option = webdriver.IeOptions()
ie_option.add_additional_option(ie_option.IGNORE_ZOOM_LEVEL, True)
ie_option.add_additional_option(
ie_option.IGNORE_PROTECTED_MODE_SETTINGS, True)
if driver_path.__len__() != 0:
webdriver_path = driver_path[0]
return webdriver.Ie(executable_path=webdriver_path,
ie_options=ie_option)
def new_browser(request):
args = request.config.getoption("--brows")
if args == "gh":
# gdd = GeckoDriverManager
# gdd.download_and_install()
option = webdriver.ChromeOptions()
# option.add_argument("--headless")
option.add_argument("--start-fullscreen")
wd = webdriver.Chrome(options=option)
elif args == "ff":
# gdd = GeckoDriverManager
# gdd.download_and_install()
option = webdriver.FirefoxOptions()
option.add_argument("--headless")
# option.add_argument("--start-maximized")
option.add_argument("--kiosk")
wd = webdriver.Firefox(options=option)
elif args == "ie":
# gdd = GeckoDriverManager
# gdd.download_and_install()
option = webdriver.IeOptions()
option.add_argument("--embedding")
# option.add_argument("-k")
wd = webdriver.Ie(options=option)
# yield wd
# wd.quit()
request.addfinalizer(wd.quit)
return wd
def _get_remote_web_driver(self, browser_name, command_executor, headless,
proxy) -> webdriver.Remote:
"""获取远程浏览器实例
:param browser_name: 浏览器类型
:param command_executor: HUB 地址
:param headless: 使用无头浏览器
:param proxy: 代理
:return: 浏览器实例
"""
if browser_name.upper() == "CHROME":
options = webdriver.ChromeOptions()
elif browser_name.upper() == "FIREFOX":
options = webdriver.FirefoxOptions()
elif browser_name.upper() == "IE":
options = webdriver.IeOptions()
else:
self.logger.error(f"浏览器类型错误：{browser_name}")
raise ValueError(f"浏览器类型错误：{browser_name}")
if proxy is not None:
options.add_argument(f"--proxy-server={proxy}")
# 无头浏览器
options.headless = headless
driver = webdriver.Remote(command_executor=command_executor,
options=options)
return driver
def __init__(self, browser, base_url, imp_wait, grid, remote):
if not grid:
if remote:
desired_cap = {
'browser': 'Chrome',
'browser_version': '70.0',
'os': 'Windows',
'os_version': '7',
'resolution': '1024x768',
'name': 'Bstack-[Python] Sample Test'
}
wd = webdriver.Remote(
command_executor=
'https://*****:*****@hub-cloud.browserstack.com/wd/hub',
desired_capabilities=desired_cap)
self.wd = EventFiringWebDriver(wd, MyListener())
else:
if browser == "chrome":
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--headless')
chrome_options.add_argument('--no-sandbox')
wd = webdriver.Chrome(options=chrome_options)
self.wd = EventFiringWebDriver(wd, MyListener())
self.wd.maximize_window()
elif browser == "firefox":
firefox_options = webdriver.FirefoxOptions()
firefox_options.headless = True
wd = webdriver.Firefox(options=firefox_options)
self.wd = EventFiringWebDriver(wd, MyListener())
self.wd.maximize_window()
elif browser == 'ie':
ie_options = webdriver.IeOptions()
ie_options.add_argument('headless')
wd = webdriver.Ie(options=ie_options)
self.wd = EventFiringWebDriver(wd, MyListener())
self.wd.maximize_window()
else:
raise ValueError("Unrecognized browser: %s" % browser)
else:
if browser == "chrome":
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--headless')
chrome_options.add_argument('--no-sandbox')
wd = webdriver.Remote(
'192.168.0.102:4444/wd/hub',
desired_capabilities=DesiredCapabilities.CHROME)
self.wd = EventFiringWebDriver(wd, MyListener())
self.wd.maximize_window()
elif browser == "firefox":
firefox_options = webdriver.FirefoxOptions()
firefox_options.headless = True
wd = webdriver.Remote(
'192.168.0.102:4444/wd/hub',
desired_capabilities=DesiredCapabilities.FIREFOX)
self.wd = EventFiringWebDriver(wd, MyListener())
self.wd.maximize_window()
self.wd.implicitly_wait(int(imp_wait))
self.base_url = base_url
self.log = create_log()
def _create_options_ins(self, browser_type: str):
browser_type = browser_type.lower()
if "chrome" in browser_type:
browser_options_ins = webdriver.ChromeOptions()
elif "firefox" in browser_type or "gecko" in browser_type:
browser_options_ins = webdriver.FirefoxOptions()
elif "ie" in browser_type:
browser_options_ins = webdriver.IeOptions()
else:
raise (f"请输入正确的浏览器类型：{browser_type}")
return browser_options_ins
def ie(self, sign_test: bool):
ie_webdriver = self.ie_path()
options = webdriver.IeOptions()
if sign_test == False:
options.headless = True
# options.require_window_focus = True
options.native_events = False
# options.ignore_protected_mode_settings = True
# options.ignore_zoom_level = True
return webdriver.Ie(executable_path=ie_webdriver, options=options)
def _launch_browser2(self, caps, download_dir):
browser_opts = self._config['browser']
options = webdriver.IeOptions()
dcaps = webdriver.DesiredCapabilities.INTERNETEXPLORER.copy()
dcaps.update(caps)
if 'binary_location' in browser_opts:
options.binary_location = browser_opts['binary_location']
browser = self._launch_browser_ie(options, dcaps)
if 'window' in browser_opts:
w, h = self._decode_win_size(browser_opts['window'])
browser.set_window_size(w, h)
return browser
def run_vote():
driver = webdriver.Chrome()
options = webdriver.IeOptions()
options.add_argument('--ignore-certificate-errors')
options.add_argument("--test-type")
driver.get(
"https://pearsbaby.ng/pears-baby-of-the-year-2019/?contest=photo-detail&photo_id=18105"
)
button = '//*[@id="main-container"]/div[2]/div/div/div/section/div[2]/div/div/div/div/section/div/div/div[2]/div/div/div[3]/div/div/div[3]/div[2]/div[1]/div[1]'
buttunpath = WebDriverWait(
driver, 1).until(lambda driver: driver.find_element_by_xpath(button))
buttunpath.click()
def __init__(self, setting):
# mkdir_func('logs')
# mkdir_func('screenshots')
settings = ['host', 'user', 'password', 'database', 'port']
if all(k in setting for k in settings):
try:
SQLconnect = SQLConnection()
self.DataBase = SQLconnect.Crawler_MySQL(setting)
logging.info('DB Connected.')
except Exception:
logging.error('Connection failed.')
logging.error(traceback.print_exc())
self.DataBase = None
else:
self.DataBase.initTable()
# self.DataBase.updateTable()
else:
self.DataBase = None
logging.info('You might need a mariaDB!!')
logging.info(setting)
if 'Chrome' in setting['browser']:
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--no-sandbox')
if setting['display'] == False:
chrome_options.add_argument('--headless')
chrome_options.add_argument('--disable-gpu')
if setting['driver']:
self.DRIVE = webdriver.Chrome(
chrome_options=chrome_options,
executable_path=setting['driver'])
else:
self.DRIVE = webdriver.Chrome(chrome_options=chrome_options)
self.URL = ""
if 'IE' in setting['browser']:
IE_options = webdriver.IeOptions()
# IE_options.add_argument('--no-sandbox')
if setting['driver']:
self.DRIVE = webdriver.Ie(ie_options=IE_options,
executable_path=setting['driver'])
else:
self.DRIVE = webdriver.Ie(ie_options=IE_options)
self.URL = ""
else:
pass
self.DRIVE.set_window_size(700, 800)
self.DRIVE.set_window_position(0, 0)
def __init__(self, browser='firefox', **kwargs):
"""initialise the web driver instance
:param browser: The web browser used
:param kwargs:
"""
options = webdriver.IeOptions() if browser == 'ie' else webdriver.ChromeOptions() if browser == 'chrome' \
else webdriver.FirefoxOptions()
# add additional optional arguments
options_args = []
if 'headless' in kwargs and kwargs.get('headless'):
options_args.append('--headless')
for op in options_args:
options.add_argument(op)
self.driver = webdriver.Ie(ie_options=options) if browser == 'ie' else webdriver.Chrome(chrome_options=options)\
if browser == 'chrome' else webdriver.Firefox(firefox_options=options)
def start_driver(browser_param):
if browser_param == "chrome":
options = webdriver.ChromeOptions()
options.add_argument("--headless")
driver = webdriver.Chrome(options=options)
return driver
elif browser_param == "firefox":
options = webdriver.FirefoxOptions()
options.add_argument("--headless")
driver = webdriver.Firefox(options=options)
return driver
elif browser_param == "ie":
options = webdriver.IeOptions()
options.add_argument("--headless")
driver = webdriver.Ie(options=options)
return driver
def openIE(self, URL, iedriverpath):
options = webdriver.IeOptions()
caps = DesiredCapabilities.INTERNETEXPLORER
caps['ignoreProtectedModeSettings'] = True
caps['initialBrowserUrl'] = "http://www.google.com.br"
options.set_capability('InternetExplorerDriver.NATIVE_EVENTS', False)
self.browser = webdriver.Ie(options=options,
executable_path=r'' + iedriverpath + '',
capabilities=caps)
if URL != "":
self.browser.get(URL)
self.logger.writeLog(
"INFO", "IE Browser Opened Successfully with URL:" + URL)
def build_options(browser, browser_options: List[str],
experimental_options: Optional[List[dict]],
extension_paths: Optional[List[str]]):
""" Build the Options object for Chrome or Firefox.
Args:
browser: The name of the browser.
browser_options: The list of options/arguments to include.
experimental_options: The list of experimental options to include.
extension_paths: The list of extensions to add to the browser session.
Examples:
WebDriverFactory().build_options('chrome', ['headless', 'incognito'], [{'useAutomationExtension', False}])
"""
browser = browser.lower()
if browser == Browser.CHROME:
options = webdriver.ChromeOptions()
elif browser == Browser.FIREFOX:
options = webdriver.FirefoxOptions()
elif browser == Browser.IE:
options = webdriver.IeOptions()
elif browser == Browser.OPERA:
options = webdriver.ChromeOptions()
elif browser == Browser.EDGE:
options = Options()
else:
raise ValueError(
f'{browser} is not supported. https://elsnoman.gitbook.io/pylenium/configuration/driver'
)
for option in browser_options:
if option.startswith('--'):
options.add_argument(option)
else:
options.add_argument(f'--{option}')
if experimental_options:
for exp_option in experimental_options:
(name, value), = exp_option.items()
options.add_experimental_option(name, value)
if extension_paths:
for path in extension_paths:
options.add_extension(path)
return options
def __init__(self):
# Opciones para Firefox
self.options = Options()
self.options.add_argument('--ignore-certificate-error')
# Opciones para Google Chrome
self.chrome_options = webdriver.ChromeOptions()
self.chrome_options.add_argument('--ignore-certificate-error')
# Opciones para Internet Explorer
self.ie_options = webdriver.IeOptions()
self.ie_options.add_argument('--ignore-certificate-error')
# Logs
self.service_args_firefox = [
'--verbose', '--log-path=./logs/firefox.log'
]
self.service_args_chrome = [
'--verbose', '--log-path=./logs/chromedriver.log'
]
self.service_args_ie = ['--verbose', '--log-path=./logs/ie.log']
def webdriver(request):
"""Return a webdriver that can be used to control a browser.
It would be nice to be able to drive the embedded browser in the wrapper
Qt app with e.g. this:
https://github.com/cisco-open-source/qtwebdriver
but it only works with the old QtWebKit, which was removed in Qt 5.6 :-/
"""
# initialize
driver = request.config.getoption("--webdriver")
from selenium import webdriver as wb
if driver == "firefox":
options = wb.FirefoxOptions()
options.headless = _pytest_options.headless
driver = wb.Firefox(options=options,
service_log_path=os.path.join(
tempfile.gettempdir(), "geckodriver.log"))
elif driver == "chrome":
options = wb.ChromeOptions()
options.headless = _pytest_options.headless
options.add_argument("--disable-gpu")
driver = wb.Chrome(options=options)
elif driver == "ie":
# NOTE: IE11 requires a registry key to be set:
# https://github.com/SeleniumHQ/selenium/wiki/InternetExplorerDriver#required-configuration
options = wb.IeOptions()
if _pytest_options.headless:
raise RuntimeError("IE WebDriver cannot be run headless.")
options.IntroduceInstabilityByIgnoringProtectedModeSettings = True
options.EnsureCleanSession = True
driver = wb.Ie(ie_options=options)
else:
raise RuntimeError("Unknown webdriver: {}".format(driver))
# set the browser size
words = _pytest_options.window_size.split("x")
driver.set_window_size(int(words[0]), int(words[1]))
# return the webdriver to the caller
try:
yield driver
finally:
driver.quit()
def __set_headless_driver(self):
if self.browser.upper() == "CHROME":
chrome_options = webdriver.ChromeOptions()
chrome_options.add_argument('--headless')
chrome_options.add_argument('--disable-gpu')
self.driver = webdriver.Chrome(executable_path=self.DRIVER_PATH,
options=chrome_options)
elif self.browser.upper() == "FIREFOX":
firefox_options = webdriver.FirefoxOptions()
firefox_options.add_argument('--headless')
firefox_options.add_argument('--disable-gpu')
self.driver = webdriver.Firefox(executable_path=self.DRIVER_PATH,
options=firefox_options)
elif self.browser.upper() == "IE":
ie_options = webdriver.IeOptions()
ie_options.add_argument('--headless')
ie_options.add_argument('--disable-gpu')
self.driver = webdriver.Ie(options=ie_options,
executable_path=self.DRIVER_PATH)
def setup(self):
# 使用action时，不支持w3c，在setup方法中定义各driver的option，
option_chrome = webdriver.ChromeOptions()
option_chrome.add_experimental_option('w3c', False)
option_ie = webdriver.IeOptions()
option_ie.add_additional_option('w3c', False)
# 定义用于执行用例的浏览器
browser = os.getenv("browser")
if browser == "ie":
self.driver = webdriver.Ie(options=option_ie)
elif browser == "friefox":
self.driver = webdriver.Firefox()
else:
self.driver = webdriver.Chrome(options=option_chrome)
# 窗口最大化
self.driver.maximize_window()
# 隐式等待3s
self.driver.implicitly_wait(3)
def initialize(options: BrowserOptions):
options_args = {}
if options.browser_name == 'firefox':
browser_options = webdriver.FirefoxOptions()
browser = webdriver.Firefox
options_args.update({'firefox_options': browser_options})
elif options.browser_name == 'safari':
browser_options = None
browser = webdriver.Safari
elif options.browser_name == 'ie':
browser_options = webdriver.IeOptions()
browser = webdriver.Ie
options_args.update({'ie_options': browser_options})
elif options.browser_name == 'edge':
browser_options = None
browser = webdriver.Edge
else:
browser_options = webdriver.ChromeOptions()
browser = webdriver.Chrome
options_args.update({'chrome_options': browser_options})
if browser_options:
if options.headless:
browser_options.add_argument('headless')
browser_options.add_argument('no-sandbox')
browser_options.add_argument('disable-gpu')
else:
browser_options.add_argument('window-size={},{}'.format(
options.wind_size_x, options.wind_size_y))
if options.executable_path:
options_args.update({'executable_path': options.executable_path})
browser = browser(**options_args)
if not options.report_dir:
options.report_dir = os.getcwd()
if not os.path.exists(options.report_dir):
os.makedirs(options.report_dir)
factory = ContextFactory(browser)
return factory.create()
def browser(request):
browser = request.config.getoption("--browser")
driver = None
if browser == "chrome":
options = webdriver.ChromeOptions()
options.headless = True
driver = webdriver.Chrome(options=options)
driver.maximize_window()
elif browser == "firefox":
options = webdriver.FirefoxOptions()
options.headless = True
driver = webdriver.Firefox(options=options)
driver.maximize_window()
elif browser == "ie":
options = webdriver.IeOptions()
options.headless = True
driver = webdriver.Ie(options=options)
driver.maximize_window()
yield driver
driver.quit()
def create_driver(self, browser_name, options, desired_capabilities):
if browser_name == 'Chrome':
driver_options = webdriver.ChromeOptions()
for option in options.arguments:
if option == '--headless' or option == '--disable-gpu' or option == '--no-sandbox':
pass
else:
driver_options.add_argument(option)
for item in options.experimental_options:
driver_options.add_experimental_option(item, options.experimental_options[item])
self.driver = webdriver.Chrome(options=driver_options, desired_capabilities=desired_capabilities)
elif browser_name == 'FireFox':
driver_options = webdriver.FirefoxOptions()
for option in options.arguments:
if option == '--headless' or option == '--disable-gpu' or option == '--no-sandbox':
pass
else:
driver_options.add_argument(option)
self.driver = webdriver.Firefox(options=driver_options, desired_capabilities=desired_capabilities)
elif browser_name == 'Ie':
driver_options = webdriver.IeOptions()
for option in options.arguments:
if option == '--headless' or option == '--disable-gpu' or option == '--no-sandbox':
pass
else:
driver_options.add_argument(option)
for item in options.additional_options:
driver_options.add_additional_option(item, options.additional_options[item])
self.driver = webdriver.Ie(options=options, desired_capabilities=desired_capabilities)
elif browser_name == 'Edge':
self.driver = webdriver.Edge(capabilities=desired_capabilities)
elif browser_name == 'PhantomJS':
self.driver = webdriver.PhantomJS(desired_capabilities=desired_capabilities)
