这部分内容是页面上的一些基本操作
from selenium.common.exceptions import TimeoutException, NoSuchElementException, WebDriverException, \
StaleElementReferenceException
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver import ActionChains
from common.KeyActions import *
from common.errors import StopTestCaseException, KTEC_WebDriverException
from selenium.webdriver.support.select import Select
from common.elementFinder import ElementFinder
from selenium.webdriver.common.keys import Keys
from common.log import *
import os, win32gui, win32con, time
from common.publicFunc import *
class BasePage(ElementFinder):
"""
Second encapsulation based on Selenium
"""
#
# def __init__(self, driver):
# self.driver = drive
def open(self, url):
""" Open url, browser maximization"""
self.driver.get(url)
self.driver.maximize_window()
def get_url(self):
url = self.driver.current_url
return url
def open_tap(self, url):
"""open a new browser tap"""
old_handles = self.get_window_handles()
simulateKey('ctrl', 't')
time.sleep(5)
for _ in range(5):
if len(self.get_window_handles()) > len(old_handles):
break
else:
time.sleep(2)
self.switch_to_window(self.get_window_handles()[len(old_handles)])
self.driver.get(url)
def close_tap(self):
"""close browser tap"""
self.driver.close()
def close_browser(self):
"""close browser"""
self.driver.quit()
def go_back(self):
"""go back"""
self.driver.back()
def refresh_(self):
"""refresh browser"""
self.driver.refresh()
def click(self, locator, isUpdated=False):
""" click element"""
# element = self.find_element_clickable(locator)
element = self.find_element_clickable(locator)
if not element:
log.warning('[BS]_436:element{ele} not exist'.format(ele=locator))
return
for _ in range(2):
log.info('[BS]_006:step --> click {ele} time={num}'.format(ele=locator, num=_ + 1))
try:
self.click_element(element)
# if Mode().getBrowserType() is None or (Mode().getBrowserType() is not None and (Mode().getBrowserType()).lower()=='ie'):
# self.driver.execute_script("$(arguments[0]).click()", element)
# else:
# self.click_element(element)
break
except KTEC_WebDriverException as e:
log.warning('[BS]_434: click {ele} failed!,{info}'.format(ele=locator, info=e))
time.sleep(1)
element = self.find_element_clickable(locator)
except Exception as e:
log.warning('[BS]_444:click {ele},unknown error:{error}'.format(ele=locator, error=e))
raise StopTestCaseException
def right_click(self, driver, locator, isUpdated=False):
""" click element"""
time.sleep(1)
# element = self.find_element_clickable(locator)
element = self.find_element_clickable(locator)
if not element:
log.warning('[BS]_436:element{ele} not exist'.format(ele=locator))
return
for _ in range(2):
log.info('[BS]_006:step --> click {ele} time={num}'.format(ele=locator, num=_ + 1))
try:
ActionChains(driver).context_click(element).perform()
# if Mode().getBrowserType() is None or (Mode().getBrowserType() is not None and (Mode().getBrowserType()).lower()=='ie'):
# self.driver.execute_script("$(arguments[0]).click()", element)
# else:
# self.click_element(element)
break
except KTEC_WebDriverException as e:
log.warning('[BS]_434: click {ele} failed!,{info}'.format(ele=locator, info=e))
time.sleep(1)
element = self.find_element_clickable(locator)
except Exception as e:
log.warning('[BS]_444:click {ele},unknown error:{error}'.format(ele=locator, error=e))
raise StopTestCaseException
def click_element(self, element):
log.info('[BS]_00601:step --> click_element')
try:
element.click()
time.sleep(1)
except StaleElementReferenceException:
raise KTEC_WebDriverException('[BS]_element is not attached to the page document')
except WebDriverException as e:
raise KTEC_WebDriverException('[BS]_element would not receive the click!{error}'.format(error=e))
except Exception as e:
log.warning('[BS]_434:unknown error! {info}'.format(info=e))
def click_by_coordinate(self, locator, xoffset=None, yoffset=None):
'''click element by coordinate'''
if xoffset is None or yoffset is None:
element = self.find_element(locator)
location = element.location
xoffset = location['x']
yoffset = location['y']
ActionChains(self.driver).move_by_offset(xoffset, yoffset).click().perform()
def input(self, locator, value, isClear=True):
""" input text """
if value is None: return
element = self.find_element_clickable(locator, timeout=3)
if not element: return
if isClear:
element.clear()
element.send_keys(value)
def scroll_element_into_view(self, locator):
"""Scrolls the element identified by ``locator`` into view."""
element = self.find_element(locator)
# Try/except can be removed when minimum required Selenium is 4.0 or greater.
try:
ActionChains(self.driver).move_to_element(element).perform()
except AttributeError:
log.warning('[BS]_Workaround for Selenium 3 bug.')
element = element.wrapped_element
ActionChains(self.driver).move_to_element(element).perform()
def drag_and_drop(self, locator, target):
"""Drags the element identified by ``locator`` into the ``target`` element.
The ``locator`` argument is the locator of the dragged element
and the ``target`` is the locator of the target. See the
`Locating elements` section for details about the locator syntax.
Example:
| `drag_and_drop(('css':'div#element'),('css':'div.target'))
"""
element = self.find_element(locator)
target = self.find_element(target)
action = ActionChains(self.driver)
action.click_and_hold(element)
action.drag_and_drop(element, target).perform()
def drag_and_drop_offset(self, locator, xoffset, yoffset):
"""Drags the element identified by ``locator`` into the ``target`` element.
The ``locator`` argument is the locator of the dragged element
and the ``target`` is the locator of the target. See the
`Locating elements` section for details about the locator syntax.
Example:
| `drag_and_drop(('css':'div#element'),('css':'div.target'))
"""
element = self.find_element(locator)
action = ActionChains(self.driver)
action.click_and_hold(element)
action.drag_and_drop_by_offset(element, xoffset, yoffset).perform()
def select_frame(self, locator):
"""Sets frame identified by ``locator`` as the current frame.
See the `Locating elements` section for details about the locator
syntax.
Works both with frames and iframes. Use `Unselect Frame` to cancel
the frame selection and return to the main frame.
"""
log.info("[BS]_Selecting frame '%s'." % locator[1])
element = self.find_element(locator)
self.driver.switch_to.frame(element)
def unselect_frame(self):
"""Sets the main frame as the current frame.
In practice cancels the previous `Select Frame` call.
"""
self.driver.switch_to.default_content()
@property
def current_url(self):
return self.driver.current_url
def wait_until_element_located_not_contains_text(self, locator, expectText, timeout=6, interval=0.5):
"""
Determine whether the text in the element is not equal to the expected text
:param expectText: expected text
:return: the actual text
"""
try:
WebDriverWait(self.driver, timeout, interval) \
.until_not(EC.text_to_be_present_in_element(locator, expectText))
current_text = self.find_element_visible(locator).text
return True, current_text
except TimeoutException:
return False, expectText
def wait_until_element_located_contains_text(self, locator, expectText, timeout=6, interval=0.5):
"""
Determine whether the text in the element is equal to the expected text
:param expectText: expected text
:return : the actual text
"""
try:
WebDriverWait(self.driver, timeout, interval) \
.until(EC.text_to_be_present_in_element(locator, expectText))
return True, expectText
except TimeoutException:
try:
current_text = self.find_element_visible(locator).text
except TimeoutException:
log.warning('[BS]_431:%s not find!' % str(locator))
else:
return False, current_text
def is_Element_Exist(self, locator, timeout=10, interval=0.5):
try:
WebDriverWait(self.driver, timeout, interval) \
.until(EC.visibility_of_element_located(locator))
return True
except Exception:
return False
def get_page_source(self):
return self.driver.page_source
def get_cookies(self):
""" get browser's cookies """
return self.driver.get_cookies()
def move_to_element(self, locator):
""" Mouse over a visible element """
element = self.find_element_visible(locator)
ActionChains(self.driver).move_to_element(element).perform()
def execute_script(self, js_command):
"""execute javascript"""
try:
self.driver.execute_script(js_command)
except Exception as e:
log.warning('[BS] excute failed %s' % e)
def switch_to_alert_and_confirm(self):
"""switch to alert window"""
self.driver.switch_to_alert().accept()
def select_item_by_value(self, locator, value):
log.info('[BS]_006:step --> select_item_by_value {ele},value={text}'.format(ele=locator, text=value))
try:
element = self.find_element_visible(locator)
Select(element).select_by_value(value)
except NoSuchElementException:
log.warning('[BS]_433:%s not in select' % value)
def select_item_by_index(self, locator, index):
log.info('[BS]_006:step --> select_item_by_index {ele},index={text}'.format(ele=locator, text=index))
try:
element = self.find_element_visible(locator)
Select(element).select_by_index(index)
except NoSuchElementException as e:
log.warning('[BS]_433:%s not in select' % index)
def select_item_by_visible_text(self, locator, text):
log.info('[BS]_006:step --> select_item_by_visible_text {ele},text={text}'.format(ele=locator, text=text))
try:
element = self.find_element_visible(locator)
Select(element).select_by_visible_text(text)
except NoSuchElementException:
log.warning('[BS]_433:%s not in select' % text)
def get_selected_item_text(self, locator):
"""Return the currently selected item of select element"""
log.info('[BS]_006:step --> get_selected_item_text {ele}'.format(ele=locator))
element = self.find_element(locator)
try:
selected_option = Select(element).first_selected_option
return selected_option.text
except TypeError:
log.warning("[BS]_432:%s not find!" % str(locator))
except NoSuchElementException:
log.warning("[BS]_433:No options are selected in %s" % str(locator))
def get_all_select_item(self, locator):
"""Returns all options in the select element"""
for _ in range(2):
log.info('[BS]_006:step --> get_all_select_item {ele}, time={num}'.format(ele=locator, num=_ + 1))
try:
element = self.find_element(locator)
selected_options = Select(element).options
if not selected_options:
break
else:
for i in range(len(selected_options)):
selected_options[i] = selected_options[i].text
except TypeError:
log.warning("[BS]_432:%s not find!" % str(locator))
break
except StaleElementReferenceException:
log.info(
'[BS]_00601:step --> element{ele} is not attached to the page document'.format(ele=locator))
continue
return selected_options
def is_element_located_selected(self, locator):
log.info('[BS]_006:step --> is_element_located_selected {ele}'.format(ele=locator))
try:
element = self.find_element_visible(locator)
element.is_selected()
return True
except TimeoutException:
log.warning('[BS]_431:%s not find!' % str(locator))
return False
def get_elements_value(self, locator, timeout=6, interval=0.5):
"""
Returns the text value of multiple elements in the list variable
"""
for _ in range(2):
log.info('[BS]_006:step --> get_elements_text {ele}, time={num}'.format(ele=locator, num=_ + 1))
result = []
try:
elements = self.find_elements(locator, timeout, interval)
if elements is not None:
for ele in elements:
result.append(ele.text)
return result
except AttributeError:
log.warning('[BS]_431:%s not find!' % str(locator))
break
except StaleElementReferenceException:
log.info(
'[BS]_00601:step --> elements{ele} is not attached to the page document'.format(ele=locator))
time.sleep(1)
continue
def get_element_text(self, locator, timeout=6, interval=0.5):
""" Return the text value of the element"""
for _ in range(2):
log.info('[BS]_006:step --> get_element_text {ele}, time={num}'.format(ele=locator, num=_ + 1))
try:
element = self.find_element(locator, timeout, interval)
return element.text
except AttributeError:
log.warning('[BS]_431:%s not find!' % str(locator))
break
except StaleElementReferenceException:
log.info(
'[BS]_00601:step --> element{ele} is not attached to the page document'.format(ele=locator))
time.sleep(1)
continue
def get_element_Attribute_value(self, locator, attribute, timeout=6, interval=0.5):
"""
Get an attribute value of an element
For example:
get_element_Attribute_value(locator=('id','xxx'),attribute='class')
"""
for _ in range(2):
log.info(
'[BS]_006:step --> get_element_Attribute_value {ele}, time={num}'.format(ele=locator, num=_ + 1))
try:
element = self.find_element(locator, timeout, interval)
try:
attributeValue = element.get_attribute(attribute)
return attributeValue
except Exception as e:
log.warning(
'431:can not get attribute [%s] value and error message is %s !' % (str(attribute), str(e)))
break
except AttributeError:
log.warning('[BS]_431:%s not find!' % str(locator))
break
except StaleElementReferenceException:
log.info(
'[BS]_00601:step --> element{ele} is not attached to the page document'.format(ele=locator))
time.sleep(1)
continue
def checkbox_is_selected(self, locator, timeout=3, interval=0.5):
"""get whether checkbox is selected"""
log.info('[BS]_006:step --> checkbox_is_selected {ele}'.format(ele=locator))
try:
WebDriverWait(self.driver, timeout, interval) \
.until(EC.element_located_to_be_selected(locator))
return True
except TimeoutException:
return False
def checkbox_is_not_selected(self, locator, timeout=3, interval=0.5):
"""get whether checkbox is not selected"""
log.info('[BS]_006:step --> checkbox_is_not_selected {ele}'.format(ele=locator))
try:
WebDriverWait(self.driver, timeout, interval) \
.until_not(EC.element_located_to_be_selected(locator))
return True
except TimeoutException:
return False
def is_visible(self, locator, timeout=1, interval=0.5):
""" Judge whether the element is visible """
log.info('[BS]_006:step --> is_visible {ele}'.format(ele=locator))
try:
WebDriverWait(self.driver, timeout, interval).until(EC.visibility_of_element_located(locator))
isdisplay = True
except TimeoutException:
isdisplay = False
return isdisplay
def is_clickable(self, locator, timeout=1, interval=0.5):
""" Judge whether the element is visible """
log.info('[BS]_006:step --> is_clickable {ele}'.format(ele=locator))
try:
WebDriverWait(self.driver, timeout, interval).until(EC.element_to_be_clickable(locator))
isdisplay = True
except TimeoutException:
isdisplay = False
return isdisplay
def is_enable(self, locator):
log.info('[BS]_006:step --> is_enable {ele}'.format(ele=locator))
try:
result = self.find_element(locator).is_enabled()
except TypeError:
return None
return result
def dismiss_alert(self):
"""dismiss alert"""
self.driver.switch_to_alert().dismiss()
def accept_alert(self):
"""Accept alert"""
self.driver.switch_to_alert().accept()
def curr_window_handle(self):
"""Get current window handle"""
handle = self.driver.current_window_handle
return handle
def get_window_handles(self):
"""Get handles of all currently open windows"""
handles = self.driver.window_handles
return handles
def switch_to_window(self, handle):
"""switch to window"""
self.driver.switch_to.window(handle)
def sendSpace(self, locator):
"""Enter SAPCE in the current element"""
self.sendKeys(locator, Keys.SPACE)
def sendEnter(self, locator):
"""Enter ENTER in the current element"""
self.sendKeys(locator, Keys.ENTER)
def sendFile(self, locator, path):
element = self.find_element(locator)
element.send_keys(path)
def take_screenshot(self, screen_dir, fileName=None):
'''
screenshot
For example:
take_screenshot(screen_dir="C:\\forder",fileName="screenshot.png")
'''
rq = time.strftime('%Y%m%d%H%M%S', time.localtime(time.time()))
if fileName is None:
fileName = rq
else:
fileName = fileName + "_" + rq
file_extension = fileName.rsplit(".", 1)
if len(file_extension) == 2:
if not file_extension[1].lower() in ['png', 'jpg', 'jpeg']:
fileName = fileName + '.png'
else:
fileName = fileName + '.png'
screen_name = os.path.join(screen_dir, fileName)
try:
self.driver.get_screenshot_as_file(screen_name)
log.info("[BS]_Had take screenshot and saved!")
except Exception as e:
log.error("[BS]_Failed to take screenshot!", format(e))
def upload_file(self, locator, filepath):
self.click(locator)
try:
if filepath is not None:
try:
dialog = win32gui.FindWindow('#32770', 'Open') # 对话框
ComboBoxEx32 = win32gui.FindWindowEx(dialog, 0, "ComboBoxEx32", None)
ComboBox = win32gui.FindWindowEx(ComboBoxEx32, 0, "ComboBox", None)
edit = win32gui.FindWindowEx(ComboBox, 0, 'Edit', None) # 上面三句依次寻找对象，直到找到输入框Edit对象的句柄
button = win32gui.FindWindowEx(dialog, 0, 'Button', None) # 确定按钮Button
win32gui.SendMessage(edit, win32con.WM_SETTEXT, None, filepath) # 往输入框输入绝对地址
win32gui.SendMessage(dialog, win32con.WM_COMMAND, 1, button) # 按button
except Exception as e:
log.error("[BS]_Failed to upload fileFormat!", format(e))
except Exception as e:
log.error(("[BS]_filepath is empty!", format(e)))
def reset_Attribute(self, locator, attribute, value):
try:
element = self.find_element(locator)
self.driver.execute_script("arguments[0].setAttribute(arguments[1],arguments[2])", element, attribute,
value)
except Exception as e:
log.error(("[BS]_attribute is not found!", format(e)))
def wait_until_disappear(self, locator, waitTime=5):
name = get_variable_name(locator)
for _ in range(5):
if self.is_visible(locator, waitTime):
time.sleep(waitTime)
log.info("waiting %s disappear" % name)
else:
log.info("waited %s disappear" % name)
break
def wait_element_visible(self, locator, waitTime=2):
for _ in range(5):
if self.is_visible(locator, waitTime):
break
else:
time.sleep(waitTime)
log.info("[BS]_wait element is visible")
def get_AttributeValue(self, locator, attribute):
try:
element = self.find_element(locator)
value = element.get_addribute(attribute)
return value
except Exception as e:
log.error(("[BS]_locator is not found!", format(e)))
if __name__ == "__main__":
'''self test'''