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 __init__(self,
options=None,
user_agent=None,
wait_time=2,
fullscreen=False,
incognito=False,
headless=False,
**kwargs):
options = Options() if options is None else options
if user_agent is not None:
options.add_argument("--user-agent=" + user_agent)
if incognito:
options.add_argument("--incognito")
if fullscreen:
options.add_argument("--kiosk")
if headless:
options.add_argument("--headless")
options.add_argument("--disable-gpu")
self.driver = Ie(options=options, **kwargs)
self.element_class = WebDriverElement
self._cookie_manager = CookieManager(self.driver)
super(WebDriver, self).__init__(wait_time)
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 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 _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 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 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
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 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 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))
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()
class Account():
"""Class to connect in you linkedin accouont"""
def __init__(self, email, password, driver_name):
""" Constructor for this class """
self.email = email
self.password = password
self.driver_name = driver_name
def connect_chrome_driver(self):
"""Functions to connect with chrome driver """
#initialise chrome options
self.options = ChromeOptions()
#add cookies on driver
self.options.add_argument("user-data-dir=selenium")
#initialise driver
self.driver = webdriver.Chrome(ChromeDriverManager().install(),
chrome_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
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 authentification(self):
#get sign in button, and click
self.sign_in_button = self.driver.find_element_by_xpath(
'//a[@class="nav__button-secondary"]').click()
#get the email field on login form
self.email_field = self.driver.find_element_by_id('username')
#get the password field on login form
self.password_field = self.driver.find_element_by_id('password')
#get the login button on login form
self.login_button = self.driver.find_element_by_xpath(
'//button[@class="btn__primary--large from__button--floating"]')
#wait 3 secondes
time.sleep(1)
#fill the location field
self.email_field.clear()
self.email_field.send_keys(self.email)
#wait 3 secondes
time.sleep(1)
#fill the location field
self.password_field.clear()
self.password_field.send_keys(self.password)
#click on login button
self.login_button.click()
def login(self):
"""Function to login in linkedin"""
#maximize the size of chrome driver
# chrome_options.add_argument("--start-maximized")
#create a webdriver object, return the object driver of type selenium.webdriver.chrome.webdriver.WebDriver
if self.driver_name == "chrome":
try:
#try to connect with chrome driver
self.driver = self.connect_chrome_driver()
except:
print(
"Sorry, you can't use chrome driver, please try another driver!"
)
sys.exit(0)
elif self.driver_name == "ie":
try:
#try to connect with ie driver
self.driver = self.connect_ie_driver()
except:
print(
"Sorry, you can't use internet explorer driver, please try another driver!"
)
sys.exit(0)
else:
try:
#try to connect with firefox driver
self.driver = self.connect_firefox_driver()
except:
print(
"sorry, you can't use firefox driver, please try another driver!"
)
sys.exit(0)
#put linkedin url in the driver
self.driver.get("https://www.linkedin.com")
#condition to verify if it is the first connection
if self.driver.current_url == "https://www.linkedin.com/feed/":
pass
else:
#call the authentification option
self.authentification()
return self.driver
exit()
# from selenium import webdriver
# from time import sleep
# driver = webdriver.Chrome(executable_path=r"C:\\Yossi\\DevOps\\0520\\4\\chromedriver.exe")
# driver.get("https://www.google.com")
# for i in range(3):
# driver.refresh()
# sleep(2)
# driver.close()
# explorer
from selenium.webdriver.ie.options import Options
ie_options = Options()
ie_options.add_argument("--disable-extensions")
driver_ie = webdriver.Ie(executable_path=IE_DRIVER_PATH, options=ie_options)
driver_ie.get("http://www.google.co.il")
sleep(1)
driver_ie.quit()
name = "yossi"
def func_name(age, n="default"):
print("hey {name}, welcome".format(name=n))
func_name(22, "aaaa")
with open("read_con.txt", "a+") as f:
f.write("fdsfdsfsdf\n")g
def assemble_driver(self):
# 若是谷歌驱动
if ConfigReader().read("project")["driver"].lower() == "chrome":
# chrome option
chrome_options = ChromeOptions()
# 服务端 root 用户不能直接运行 chrome，添加此参数可以运行
chrome_options.add_argument('--no-sandbox')
# # 下面参数可自行选择
# chrome_options.add_argument('--user-data-dir')
# chrome_options.add_argument('--dns-prefetch-disable')
# chrome_options.add_argument('--lang=en-US')
# chrome_options.add_argument('--disable-setuid-sandbox')
# chrome_options.add_argument('--disable-gpu')
# 驱动路径
executable_path = os.path.abspath(
os.path.dirname(__file__)
)[:os.path.abspath(os.path.dirname(__file__)
).find("python-ui-auto-test") +
len("python-ui-auto-test")] + "/ui-test" + ConfigReader().read(
"driver")["chrome_driver_path"]
# 如果读取不到 remote_ip 或者 remote_port 就不用远端浏览器
if ConfigReader().read(
"project")["remote_ip"] == "" or ConfigReader().read(
"project")["remote_port"] == "":
self.driver = webdriver.Chrome(executable_path=executable_path,
chrome_options=chrome_options)
# 使用远端浏览器
else:
url = "http://" + ConfigReader().read(
"project")["remote_ip"] + ":" + ConfigReader().read(
"project")["remote_port"] + "/wd/hub"
self.driver = RemoteWebDriver(command_executor=url,
options=chrome_options)
# 若是火狐驱动
elif ConfigReader().read("project")["driver"].lower() == "firefox":
# firefox option
firefox_options = FirefoxOptions()
# 服务端 root 用户不能直接运行 chrome，添加此参数可以运行
firefox_options.add_argument('--no-sandbox')
# 驱动路径
executable_path = os.path.abspath(
os.path.dirname(__file__)
)[:os.path.abspath(os.path.dirname(__file__)
).find("python-ui-auto-test") +
len("python-ui-auto-test")] + "/ui-test" + ConfigReader().read(
"driver")["firefox_driver_path"]
# 获取驱动自己产出日志路径
log_path = os.path.abspath(
os.path.dirname(__file__)
)[:os.path.abspath(os.path.dirname(__file__)
).find("python-ui-auto-test") +
len("python-ui-auto-test")] + "/ui-test" + ConfigReader().read(
"log")["logfile_path"]
self.driver = webdriver.Firefox(executable_path=executable_path,
log_path=log_path +
"geckodriver.log",
firefox_options=firefox_options)
# 若是 IE 驱动
elif ConfigReader().read("project")["driver"].lower() == "ie":
# ie option
ie_options = IeOptions()
# 服务端 root 用户不能直接运行 chrome，添加此参数可以运行
ie_options.add_argument('--no-sandbox')
# 驱动路径
executable_path = os.path.abspath(
os.path.dirname(__file__)
)[:os.path.abspath(os.path.dirname(__file__)
).find("python-ui-auto-test") +
len("python-ui-auto-test")] + "/ui-test" + ConfigReader().read(
"driver")["ie_driver_path"]
self.driver = webdriver.Ie(executable_path=executable_path,
ie_options=ie_options)
# 若是 Edge 驱动
elif ConfigReader().read("project")["driver"].lower() == "edge":
executable_path = os.path.abspath(
os.path.dirname(__file__)
)[:os.path.abspath(os.path.dirname(__file__)
).find("python-ui-auto-test") +
len("python-ui-auto-test")] + "/ui-test" + ConfigReader().read(
"driver")["edge_driver_path"]
self.driver = webdriver.Edge(executable_path=executable_path)
# 若是欧朋驱动
elif ConfigReader().read("project")["driver"].lower() == "opera":
executable_path = os.path.abspath(
os.path.dirname(__file__)
)[:os.path.abspath(os.path.dirname(__file__)
).find("python-ui-auto-test") +
len("python-ui-auto-test")] + "/ui-test" + ConfigReader().read(
"driver")["opera_driver_path"]
self.driver = webdriver.Opera(executable_path=executable_path)
# 若是 Safari 驱动
elif ConfigReader().read("project")["driver"].lower() == "safari":
executable_path = os.path.abspath(
os.path.dirname(__file__)
)[:os.path.abspath(os.path.dirname(__file__)
).find("python-ui-auto-test") +
len("python-ui-auto-test")] + "/ui-test" + ConfigReader().read(
"driver")["safari_driver_path"]
self.driver = webdriver.Safari(executable_path=executable_path)
# 不支持的浏览器类型
else:
self.driver = None
raise RuntimeError("配置文件中配置了不支持的浏览器类型！请修改浏览器类型！")
def ost_driver(request):
"""
driver注入
@param request:
@return:
"""
browser = request.config.getoption("--browser")
# It is used to set whether or not to open the browser for local startup,browser_opt judge，default:open
browser_opt = request.config.getoption("--browser_opt")
logging.info(f'Get command line parameters:{request.config.getoption("--browser")}')
type_driver = request.config.getoption("--type_driver")
# Determine whether it is distributed locally or remotely
if type_driver == "local":
if browser_opt == "open":
if browser == "chrome":
# Skip non secure HTTPS security verification
chrome_options = CO()
chrome_options.add_argument("--ignore-certificate-errors")
driver = webdriver.Chrome(chrome_options=chrome_options)
elif browser == "firefox":
# Skip non secure HTTPS security verification
profile = FP()
profile.accept_untrusted_certs = True
driver = webdriver.Firefox(firefox_profile=profile)
elif browser == "ie":
# Skip non secure HTTPS security verification
driver = webdriver.Ie()
else:
logging.info(f"Bad browser parameters:{browser}")
else:
if browser == "chrome":
# Do not open the browser window, run the test code in the background
chrome_options = CO()
chrome_options.add_argument('--headless')
# Skip non secure HTTPS security verification
chrome_options.add_argument('--ignore-certificate-errors')
driver = webdriver.Chrome(chrome_options=chrome_options)
elif browser == "firefox":
# Do not open the browser window, run the test code in the background
firefox_options = FO()
firefox_options.add_argument('--headless')
# Skip non secure HTTPS security verification
profile = FP()
profile.accept_untrusted_certs = True
driver = webdriver.Firefox(firefox_options=firefox_options, firefox_profile=profile)
elif browser == "ie":
# Do not open the browser window, run the test code in the background
ie_options = IEO()
ie_options.add_argument('--headless')
# Skip non secure HTTPS security verification
driver = webdriver.Ie(ie_options=ie_options)
else:
logging.info(f"Received incorrect browser parameters:{browser}")
return driver
elif type_driver == "remote":
# Read selenium distributed configuration file
selenium_config_path = os.path.join(os.getcwd(), "Conf", "config.yaml")
selenium_config = FileOption.read_yaml(selenium_config_path)
driver = Remote(command_executor=selenium_config["selenium_config"]["selenium_hub_url"],
desired_capabilities={'platform': 'ANY', 'browserName': browser, 'version': '',
'javascriptEnabled': True})
return driver
else:
logging.error(f"driver parameter transfer error, please check the parameter:{type_driver}")