def set_up_driver(self,
selenoid,
browser_key,
lang,
capabilities=None,
is_incognito=False,
enable_performance_logging=False,
test_name=None):
Logger.info('Create driver for browser ' + browser_key)
if browser_key in self.__web_driver:
raise ValueError(
"Browser with key '{}', was created.".format(browser_key))
self.__web_driver[browser_key] = \
BrowserFactory.get_browser_driver(browser_key=browser_key,
lang=lang,
capabilities=capabilities,
is_incognito=is_incognito,
enable_performance_logging=enable_performance_logging,
test_name=test_name, selenoid=selenoid)
self.__web_driver[browser_key].implicitly_wait(
Waits.IMPLICITLY_WAIT_SEC)
self.__web_driver[browser_key].set_page_load_timeout(
Waits.PAGE_LOAD_TIMEOUT_SEC)
self.__web_driver[browser_key].set_script_timeout(
Waits.SCRIPT_TIMEOUT_SEC)
self.__main_window_handle = self.__web_driver[
browser_key].current_window_handle
self.select_browser(browser_key)
def switch_new_window(self, logged_page_name=""):
Logger.info("Switch to new window %s" % logged_page_name)
handles = self.get_driver().window_handles
if len(handles) <= 1:
raise NoSuchWindowException(
"There is no window. Count windows is %s" % len(handles))
self.get_driver().switch_to_window(handles[-1])
def send_keys_without_click(self, key):
Logger.info("send_keys: Change text for an item '" + self.get_name() +
" " + self.__class__.__name__ + "'" + "' to text => '" +
key + "'")
self.wait_for_is_visible()
element = self.wait_for_clickable()
element.send_keys(key)
def set_session_screen_dir():
lock = threading.Lock()
lock.acquire()
try:
if not os.path.exists(Screenshooter.__screen_dir):
Logger.info("Creating a directory for storing screenshots: " +
Screenshooter.__screen_dir)
os.makedirs(Screenshooter.__screen_dir)
new_screen_path = os.path.join(
Screenshooter.__screen_dir,
"Session_" + DatetimeUtil.get_str_datetime(
screenshots.FORMAT_DATETIME_FOR_SCREEN))
if Screenshooter.__session_dir is None and not os.path.exists(
new_screen_path):
Screenshooter.__session_dir = new_screen_path
else:
Screenshooter.__session_dir = new_screen_path + "." + str(
datetime.now().microsecond)
Logger.info("Creating a directory " + new_screen_path)
os.makedirs(Screenshooter.__session_dir)
finally:
lock.release()
def get_value(self):
self.wait_for_is_present()
value = super(TextBox, self).get_attribute("value")
Logger.info("Method get_value in item " + self.get_name() + " " +
self.get_element_type() + " получил значение: " +
str(value))
return value
def get_text(self):
Logger.info("get_text: Receiving text element '" + self.get_name() +
"'")
self.wait_for_is_present()
text = self.find_element().text
Logger.info("get_text: Received text '" + text + "'")
return text
def wait_for_check_by_condition(self, waiter, time_in_seconds=Waits.IMPLICITLY_WAIT_SEC, message=""):
try:
WebDriverWait(self.get_driver(), time_in_seconds).until(waiter)
except TimeoutException:
error_msg = "After {time} seconds has passed, the event failed: {msg}".format(time=time_in_seconds,
msg=message)
Logger.warning(error_msg)
raise TimeoutException(error_msg)
def take_screenshot():
screen_name = Screenshooter.get_screen_file_name()
save_screen_path = os.path.join(Screenshooter.__session_dir, screen_name)
Logger.info("Screenshot capture to file " + screen_name)
Browser.get_browser().get_driver().save_screenshot(save_screen_path)
result_image = Image.open(save_screen_path)
Logger.info(VisualRecord(screen_name, result_image))
def switch_to_window(self, window_handle=None):
if window_handle is None:
window_handle = self.__main_window_handle
Logger.info("Switch to window %s" % window_handle)
try:
self.get_driver().switch_to_window(window_handle)
except NoSuchWindowException:
Logger.error("Window with name not found %s" % window_handle)
def click(self):
Logger.info("click: Click on an item '" + self.get_name() + " " + self.__class__.__name__ + "'")
def func():
self.find_element().click()
return True
self.wait_for(func)
def wait_for_check_by_condition(self, method_to_check, message,
wait_time_sec=Waits.EXPLICITLY_WAIT_SEC, use_default_msg=True):
try:
element = WebDriverWait(Browser.get_browser().get_driver(), wait_time_sec).until(method=method_to_check)
except TimeoutException:
result_message = ("item '" + self.get_name() + "' with locator " + self.get_locator() + message
if use_default_msg else message)
Logger.warning(result_message)
raise TimeoutException(result_message)
return element
def get_displayed_elements(condition, locator):
element_size = len(Browser.get_browser().get_driver().find_elements(condition, locator))
result_elements = []
try:
for ele_number in range(1, element_size + 1):
element_locator = "({locator})[{number}]".format(locator=locator, number=ele_number)
Logger.info("Search for an item with a locator " + element_locator)
element = WebDriverWait(Browser.get_browser().get_driver(), Waits.EXPLICITLY_WAIT_SEC).until(
ec.visibility_of_element_located((condition, element_locator)))
result_elements.append(element)
except TimeoutException:
error_msg = "item with locator was not found"
Logger.error(error_msg)
raise TimeoutException(error_msg)
return result_elements
def get_attribute(self, attr):
Logger.info("get_attribute: Get attribute " + attr + " for item '" + self.get_name() + "'")
self.wait_for_is_visible()
return self.find_element().get_attribute(name=attr)
# -*- coding:utf-8 -*-
import os.path
from configparser import ConfigParser
from selenium import webdriver
from framework.utils.logger import Logger
logger = Logger(logger="BrowserEngine").getlog()
class BrowserEngine(object):
dir = os.path.dirname(os.path.abspath('.')) # 注意相对路径获取方法
chrome_driver_path = dir + '/tools/chromedriver.exe'
ie_driver_path = dir + '/tools/IEDriverServer.exe'
def __init__(self, driver):
self.driver = driver
# read the browser type from config.ini file, return the driver
def open_browser(self, driver):
config = ConfigParser()
# file_path = os.path.dirname(os.getcwd()) + '/config/config.ini'
file_path = os.path.dirname(
os.path.abspath('.')) + '/config/config.ini'
config.read(file_path)
browser = config.get("browserType", "browserName")
logger.info("You had select %s browser." % browser)
url = config.get("testServer", "URL")
logger.info("The test server url is: %s" % url)
def refresh_page(self):
Logger.info("Page Refresh " + self.page_name)
Browser.get_browser().refresh_page()
def refresh_page(self):
Logger.info("Reload page")
self.get_driver().refresh()
def double_click(self):
self.wait_for_is_visible()
Logger.info("double_click: Double click on an item '" + self.get_name() + "'")
ActionChains(Browser.get_browser().get_driver()).double_click(self.find_element()).perform()
def dismiss_alert(self):
Logger.info("Close alert")
self.switch_to_alert().dismiss()
def quit(self, browser_key=BrowserConfig.BROWSER):
browser_inst = self.__web_driver.get(browser_key)
if browser_inst is not None:
Logger.info("Stop driver work")
browser_inst.quit()
self.__web_driver.pop(browser_key, None)
# coding=utf-8
import time
from selenium.common.exceptions import NoSuchElementException
import os.path
from framework.utils.logger import Logger
from selenium.webdriver.support.select import Select
# create a logger instance
logger = Logger(logger="BasePage").getlog()
class BasePage(object):
"""
定义一个页面基类，让所有页面都继承这个类，封装一些常用的页面操作方法到这个类
"""
def __init__(self, driver):
self.driver = driver
# quit browser and end testing
def quit_browser(self):
self.driver.quit()
# 浏览器前进操作
def forward(self):
self.driver.forward()
logger.info("Click forward on current page.")
# 浏览器后退操作
def get_cookie(self, name):
Logger.info("Get cookie with name: " + name)
return self.get_driver().get_cookie(name=name)
def get_cookies(self):
Logger.info("Getting all cookies")
return self.get_driver().get_cookies()
def set_url(self, url):
Logger.info("Change url page on " + url)
self.get_driver().get(url)
def get_css_value(self, property_name):
Logger.info("get_attribute: Get attribute CSS" + property_name + " for item '" + self.get_name() + "'")
self.wait_for_is_visible()
return self.find_element().value_of_css_property(property_name=property_name)
def scroll_by_script(self):
self.wait_for_is_visible()
Logger.info("Scroll to item '" + self.get_name() + "'")
Browser.get_browser().execute_script(scripts_js.SCROLL_INTO_VIEW, self.find_element())
def send_alert_text(self, text):
Logger.info(f"Send to alert text {text}")
self.switch_to_alert().send_keys(text)
def is_opened(self):
Logger.info("Check if the page is open " + self.page_name)
self.wait_page_to_load()
return Browser.get_browser().is_wait_successful(
Label(self.search_condition, self.locator,
self.page_name).wait_for_is_visible)
def wait_for_page_opened(self):
Logger.info("Waiting for page to load " + self.page_name +
" and visibility of its identifying element")
self.wait_page_to_load()
Label(self.search_condition, self.locator,
self.page_name).wait_for_is_visible()
def wait_page_to_load(self):
Logger.info("Waiting for page to load " + self.page_name + " using js")
Browser.get_browser().wait_for_page_to_load()
def close(self, page_name=""):
if self.get_driver() is not None:
Logger.info("CLose page %s " % page_name)
self.get_driver().close()