def test_04(self):
see_located = self.fd.get_located('SeeResult', 'Node4',
'practice_element.ini')
enter_here = self.fd.get_element('EnterHere', 'Node4',
'practice_element.ini')
check_submit = self.fd.get_element('CheckSubmit', 'Node4',
'practice_element.ini')
submit = self.fd.get_element('Submit', 'Node4', 'practice_element.ini')
keyup = self.fd.get_element('KeyUp', 'Node4', 'practice_element.ini')
keypress = self.fd.get_element('KeyPress', 'Node4',
'practice_element.ini')
if WD(self.driver,
10).until(EC.visibility_of_element_located(see_located),
'有效时间内没有进入页面'):
AC(self.driver).send_keys_to_element(
enter_here,
'大家好').send_keys_to_element(check_submit,
'qiehuan').click(submit).perform()
time.sleep(2)
AC(self.driver).key_down(
Keys.CONTROL,
enter_here).send_keys('a').key_up(Keys.CONTROL).send_keys(
Keys.BACKSPACE).send_keys('new').perform()
if WD(self.driver, 10).until(EC.visibility_of(keyup)):
AC(self.driver).click(keyup).send_keys(Keys.DOWN, Keys.DOWN,
Keys.ENTER).perform()
time.sleep(2)
result = keypress.is_selected()
self.assertTrue(result)
time.sleep(2)
def wait_element_visible(self,
locator,
times=30,
poll_frequency=0.5,
doc=""):
"""
等待元素
:param locator: 元素定位（元祖形式：元素定位类型、元素定位方式）
:param times: 等待时间30s
:param poll_frequency: 等待周期
:param doc: 模块名——页面名——操作名
:return: none
"""
self.logger.info(f"等待元素{locator}可见")
try:
# 开始等待的时间
time_start = datetime.datetime.now()
WD(self.driver, times, poll_frequency).until(
EC.visibility_of_all_elements_located(locator))
# 结束等待时间
time_end = datetime.datetime.now()
time_wait = (time_end - time_start).seconds
# 打印日志
self.logger.info(
f"等待元素{locator}可见结束，开始时间{time_start},结束时间{time_end},等待时长{time_wait}"
)
except:
# 捕捉异常
self.logger.exception("等待元素可见失败！")
# 截图
self.screenshot()
raise
def wait_element_to_be_located(self, by, locator):
"""显示等待某个元素出现，且可见"""
print('info:waiting "{}" to be located'.format(locator))
try:
return WD(self.driver, self.outTime).until(ec.presence_of_element_located((self.byDic[by], locator)))
except TimeoutException as t:
print('error: found "{}" timeout！'.format(locator), t)
def wait_element_to_be_located(self, by, locator):
"""显示等待某个元素出现，且可见"""
# logger.info(f'waiting {locator} to be located')
try:
return WD(self.driver, self.timeout).until(
ec.presence_of_element_located((self.byDic[by], locator)))
except TimeoutException as t:
logger.warning(f'found {locator} timeout！:{t}')
def get_elements(self, *locator, doc="", is_displayed=True):
ele_v = WD(self.driver, 30, 0.5).until(
EC.visibility_of_element_located(locator)) # 元素可见
ele_p = WD(self.driver, 30,
0.5).until(EC.presence_of_element_located(locator)) # 元素存在
ele_va = WD(self.driver, 30, 0.5).until(
EC.visibility_of_all_elements_located(locator)) #
ele_pa = WD(self.driver, 30,
0.5).until(EC.presence_of_all_elements_located(locator))
method, value = locator.split(',', maxsplit=1)
if 'css' in method:
method = By.CSS_SELECTOR
elif 'class' in method:
method = By.CLASS_NAME
elif 'text' in method:
method = By.PARTIAL_LINK_TEXT
elif 'tag' in method:
method = By.TAG_NAME
elif 'id' in method:
method = By.ID
elif 'xpath' in method:
method = By.XPATH
elements = self.driver.find_elements(by=method, value=value)
new_elements = []
for element in elements:
try:
if ele_pa != '':
if is_displayed:
if element.is_displayed():
new_elements.append(element)
else:
new_elements.append(element)
else:
if is_displayed:
if element.is_displayed():
new_elements.append(element)
else:
new_elements.append(element)
return new_elements
except:
self.logger.exception("查找元素失败！请检查元素是否存在")
self.screenshot()
raise
def send_keys(self, value, by, locator=''):
"""写数据"""
print('info:input "{}"'.format(value))
try:
element = WD(self.driver, 30).until(
EC.presence_of_element_located((by, locator)))
element.send_keys(value)
time.sleep(1)
except AttributeError as e:
print(e)
def find_element_presence(self, *locator, doc=""):
"""元素存在dom中，即被找到"""
self.logger.info(f"{doc}查找存在dom中元素：{locator}")
try:
WD(self.driver,
10).until(EC.presence_of_element_located(locator)) # 显示等待
return self.driver.find_element(*locator)
except:
# print(locator, '页面未找到元素')
self.logger.warning(locator, '页面未找到元素')
def is_alert(self):
"""
判断alert弹框存在
"""
try:
re = WD(self.driver, self.outTime).until(EC.alert_is_present())
except (TimeoutException, NoAlertPresentException):
print("error:no found alert")
else:
return re
def is_alert(self):
"""
assert alert if exsit
:return: alert obj
"""
try:
re = WD(self.driver, self.outTime).until(ec.alert_is_present())
except (TimeoutException, NoAlertPresentException):
print("error:no found alert")
else:
return re
def switch_to_frame(self, by, locator):
"""判断frame是否存在，存在就跳到frame"""
print('info:switching to iframe "{}"'.format(locator))
if by.lower() in self.byDic:
try:
WD(self.driver, self.outTime). \
until(ec.frame_to_be_available_and_switch_to_it((self.byDic[by], locator)))
except TimeoutException as t:
print('error: found "{}" timeout！切换frame失败'.format(locator), t)
else:
print('the "{}" error!'.format(by))
def is_click(self, by, locator):
if by.lower() in self.byDic:
try:
element = WD(self.driver, self.timeout). \
until(ec.element_to_be_clickable((self.byDic[by], locator)))
except TimeoutException:
logger.warning("元素不可以点击")
else:
return element
else:
logger.error(f'the {by} error!')
def is_click(self, by, locator):
if by.lower() in self.byDic:
try:
element = WD(self.driver, self.outTime). \
until(ec.element_to_be_clickable((self.byDic[by], locator)))
except TimeoutException:
print("元素不可以点击")
else:
return element
else:
print('the "{}" error!'.format(by))
def is_alert(self):
'''
assert alert if exsit
:return:
'''
try:
re = WD(self.driver, self.outTime).until(ec.alert_is_present())
except (TimeoutException, NoAlertPresentException):
self.loger.info("error:no found alert")
else:
return re
def switch_to_frame(self, by, locator):
"""判断frame是否存在，存在就跳到frame"""
# logger.info(f'info:switching to iframe "{locator}"')
if by.lower() in self.byDic:
try:
WD(self.driver, self.timeout). \
until(ec.frame_to_be_available_and_switch_to_it((self.byDic[by], locator)))
except TimeoutException as t:
logger.warning(
f'error: found {locator} timeout！切换frame失败!:{t}')
else:
logger.error(f'the {by} error!')
def wait_element_to_be_located(self, by, locator):
'''
显示等待值
:param by: 元素定位方式
:param locator: 元素定位值
:return:
'''
self.loger.info('info:waiting "{}" to be located'.format(locator))
try:
return WD(self.driver, self.outTime).until(ec.presence_of_element_located((self.byDic[by], locator)))
except TimeoutException as t:
self.loger.info('error: found "{}" timeout！'.format(locator), t)
def find_elements(self, *locator, doc=""):
"""
寻找多个元素
:param locator: (BY.XPATH, //div)
:param doc: 记录日志描述：模块名——页面名——操作名
:return:
"""
self.logger.info(f"{doc}界面，查找元素：{locator}")
elements = self.driver.find_elements(*locator)
new_elements = []
try:
for element in elements:
try:
# ele_va = WD(self.driver, 90, 0.5).until(EC.visibility_of_all_elements_located(locator)) # 元素可见
WD(self.driver, 30, 0.5).until(
EC.visibility_of_element_located(locator)) # 元素可见
new_elements.append(element)
except:
# ele_pa = WD(self.driver, 90, 0.5).until(EC.presence_of_all_elements_located(locator)) # 所有元素存在
WD(self.driver, 30, 0.5).until(
EC.presence_of_element_located(locator)) # 元素存在
new_elements.append(element)
return new_elements
# try:
# # ele_pa = WD(self.driver, 90, 0.5).until(EC.presence_of_all_elements_located(locator)) # 所有元素存在
# ele_p = WD(self.driver, 90, 0.5).until(EC.presence_of_element_located(locator)) # 元素存在
# for element in elements:
# if ele_p != '':
# # ele_va = WD(self.driver, 90, 0.5).until(EC.visibility_of_all_elements_located(locator)) # 元素可见
# ele_v = WD(self.driver, 90, 0.5).until(EC.visibility_of_element_located(locator)) # 元素可见
# if ele_v != '':
# new_elements.append(element)
# else:
# new_elements.append(element)
# # print(new_elements)
# return new_elements
except:
self.logger.exception(f"{doc}界面，查找元素：{locator}失败！请检查元素是否存在")
self.screenshot()
raise
def test_02(self):
find_dragme = self.fd.get_element('dragme', 'Node2',
'practice_element.ini')
find_ltem1 = self.fd.get_element('ltem1', 'Node2',
'practice_element.ini')
find_ltem4 = self.fd.get_element('ltem4', 'Node2',
'practice_element.ini')
locator_ltem1 = self.fd.get_located('ltem1', 'Node2',
'practice_element.ini')
if WD(self.driver,
10).until(EC.title_is('Mootools Drag and Drop Example')):
if WD(self.driver,
10).until(EC.visibility_of_element_located(locator_ltem1)):
AC(self.driver).drag_and_drop(find_dragme,
find_ltem1).perform()
time.sleep(2)
AC(self.driver).drag_and_drop(find_dragme,
find_ltem4).perform()
time.sleep(2)
text = WD(self.driver, 5).until(
EC.text_to_be_present_in_element(locator_ltem1, 'dropped'))
self.assertTrue(text, '用例失败')
def find_elements(self, by, locator):
"""
find group elements
:param by: eg: id, name, xpath, css.....
:param locator: eg: id, name, xpath for str
:return: elements object
"""
try:
print('[Info:start find the elements "{}" by "{}"!]'.format(locator, by))
elements = WD(self.driver, self.outTime).until(lambda x: x.find_elements(by, locator))
except TimeoutException as t:
print('error: found "{}" timeout!'.format(locator), t)
else:
return elements
def find_element(self, by, locator):
"""
find alone element
:param by: eg: id, name, xpath, css.....
:param locator: id, name, xpath for str
:return: element object
"""
try:
self.loger.info('[Info:Starting find the element "{}" by "{}"!]'.format(locator, by))
element = WD(self.driver, self.outTime).until(lambda x: x.find_element(by, locator))
except TimeoutException as t:
self.loger.info('error: found "{}" timeout!'.format(locator), t)
else:
return element
def find_element(self, by, locator):
"""
查找单个元素
"""
try:
print('[Info:Starting find the element "{}" by "{}"!]'.format(
locator, by))
element = WD(
self.driver,
self.timeout).until(lambda x: x.find_element(by, locator))
except TimeoutException as t:
print('error: found "{}" timeout!'.format(locator), t)
else:
return element
def is_element_exist(self, by, locator):
"""
判断元素可见
"""
if by.lower() in self.byDic:
try:
WD(self.driver, self.outTime). \
until(EC.visibility_of_element_located((self.byDic[by], locator)))
except TimeoutException:
print('Error: element "{}" not exist'.format(locator))
return False
return True
else:
print('the "{}" error!'.format(by))
def find_elements(self, by, locator):
"""
查找一组元素
"""
try:
print('[Info:start find the elements "{}" by "{}"!]'.format(
locator, by))
elements = WD(
self.driver,
self.outTime).until(lambda x: x.find_elements(by, locator))
except TimeoutException as t:
print('error: found "{}" timeout!'.format(locator), t)
else:
return elements
def find_element_presence(self, *locator, doc=""):
"""
元素存在dom中，即被找到
:param locator: (BY.XPATH, //div)
:param doc: 记录日志描述：模块名——页面名——操作名
:return:
"""
self.logger.info(f"{doc}界面，查找存在dom中元素：{locator}")
try:
WD(self.driver,
10).until(EC.presence_of_element_located(locator)) # 显示等待
return self.driver.find_element(*locator)
except:
self.logger.warning(f"{doc}界面，未找到{locator}元素！")
raise
def test_01(self):
if WD(self.driver, 10).until(
EC.text_to_be_present_in_element(
self.fd.get_located('check', 'Node1',
'practice_element.ini'),
'Prompt Test')):
print('True')
AC(self.driver).click(
self.fd.get_element('click', 'Node1',
'practice_element.ini')).perform()
time.sleep(2)
if WD(self.driver, 5).until(EC.alert_is_present()):
AL(self.driver).send_keys('sahai test')
time.sleep(1)
AL(self.driver).accept()
if WD(self.driver, 5).until(
EC.element_to_be_clickable(
self.fd.get_located('prompt_by', 'Node1',
'practice_element.ini'))):
AC(self.driver).click(
self.fd.get_element('back', 'Node1',
'practice_element.ini')).perform()
wu = WD(self.driver, 5).until(EC.title_is('Sahi Tests'))
self.assertTrue(wu)
def find_elements(self, by, locator):
"""
find group elements
:param by: eg: id, name, xpath, css.....
:param locator: eg: id, name, xpath for str
:return: elements object
"""
try:
# logger.info(f'start find the elements {locator} by {by}')
elements = WD(
self.driver,
self.timeout).until(lambda x: x.find_elements(by, locator))
except TimeoutException as t:
logger.warning(f'error: found "{locator}" timeout!:{t}')
else:
return elements
def find_element(self, by, locator):
"""
find alone element
:param by: eg: id, name, xpath, css.....
:param locator: id, name, xpath for str
:return: element object
"""
try:
logger.info(f'Starting find the element {locator} by {by}!')
element = WD(
self.driver,
self.timeout).until(lambda x: x.find_element(by, locator))
except TimeoutException:
logger.warning(f'error: found {locator} timeout!')
else:
return element
def switch_to_frame(self, by, locator):
'''
判断frame是否存在，存在就跳到frame
:param by: 元素定位方式
:param locator: 元素定位值
:return:
'''
self.loger.info('info:switching to iframe "{}"'.format(locator))
if by.lower() in self.byDic:
try:
WD(self.driver, self.outTime). \
until(ec.frame_to_be_available_and_switch_to_it((self.byDic[by], locator)))
except TimeoutException as t:
self.loger.info('error: found "{}" timeout！切换frame失败'.format(locator), t)
else:
self.loger.info('the "{}" error!'.format(by))
def get_element_text(self, by, locator=None):
"""获取某一个元素的text信息"""
try:
element = WD(self.driver, 30).until(
EC.visibility_of_element_located((self.byDic[by], locator)))
# element = WD(self.driver,30).until(
# EC.presence_of_element_located((self.byDic[by], locator))
# )
print("element.text:{}".format(element.text))
return element.text
except AttributeError:
print('get "{}" text failed return None'.format(locator))
def is_element_exist(self, by, locator):
"""
assert element if exist
:param by: eg: id, name, xpath, css.....
:param locator: eg: id, name, xpath for str
:return: if element return True else return false
"""
if by.lower() in self.byDic:
try:
WD(self.driver, self.outTime). \
until(ec.visibility_of_element_located((self.byDic[by], locator)))
except TimeoutException:
print('Error: element "{}" not exist'.format(locator))
return False
return True
else:
print('the "{}" error!'.format(by))
def is_click(self, by, locator):
'''
判断元素是否可点击
:param by: 元素定位方式
:param locator: 元素定位置
:return: 若可以点击，返回元素对象
'''
if by.lower() in self.byDic:
try:
element = WD(self.driver, self.outTime). \
until(ec.element_to_be_clickable((self.byDic[by], locator)))
except TimeoutException:
self.loger.info("元素不可以点击")
else:
return element
else:
self.loger.info('the "{}" error!'.format(by))
