def GetParentElement(self):
logger.step_normal("Element [%s]: GetParentElement()" % self.__name__)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
return elements[self.index].parent()
def cell_by_row_and_col_name(self, row_name, col_name):
for rowx in range(0, self.nrows()):
if self.cellxy(rowx, 0) == row_name:
logger.step_normal("Excel row_name=" + row_name + ", col_name=" + col_name + ", value=" + self.cell(rowx, col_name))
return self.cell(rowx, col_name)
return None
def VerifyExistence(self, trueORfalse):
"""
EXAMPLE
Page.Element.VerifyExistence(True)
:param trueORfalse: True or False
:return:
"""
logger.step_normal("Element [%s]: Verify Existence = [%s]." %
(self.__name__, trueORfalse))
if trueORfalse is True:
self.__wait_for_appearing()
else:
self.__wait_for_disappearing()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
logger.step_normal("Element [%s]: Count = [%s]" %
(self.__name__, len(elements)))
if len(elements) > 0:
if trueORfalse is True:
logger.step_pass("Exist!")
else:
logger.step_fail("Exist!")
else:
if trueORfalse is False:
logger.step_pass("Not Exist!")
else:
logger.step_fail("Not Exist!")
def VerifyEnabled(self, trueOrfalse):
logger.step_normal("Element [%s]: Verify Enabled = [%s]" %
(self.__name__, trueOrfalse))
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
is_disabled = elements[self.index].get_attribute("disabled")
logger.step_normal("Element [%s]: attribute 'is_disabled' = [%s]" %
(self.__name__, is_disabled))
if is_disabled == "true":
if trueOrfalse is False:
logger.step_pass("Pass...")
else:
logger.step_fail("Fail...")
elif elements[self.index].is_enabled():
if trueOrfalse is True:
logger.step_pass("Pass")
else:
logger.step_fail("Fail")
else:
logger.step_fail("Not verified.")
def GetParentElement(self):
logger.step_normal("Element [%s]: GetParentElement()" % self.__name__)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
return elements[self.index].parent()
def __wait_for_disappearing(self):
t = 0
while t < 120:
t = t + 1
try:
elements = Browser.RunningBrowser.find_elements(
self.by, self.value)
except NoSuchElementException:
logger.step_normal("Element [%s]: NoSuchElementException." %
self.__name__)
elements = []
continue
except UnexpectedAlertPresentException:
logger.step_warning(
"Element [%s]: UnexpectedAlertPresentException." %
self.__name__)
if len(elements) == 0:
return True
else:
time.sleep(0.5)
logger.step_normal(
"Element [%s]: WairForDisappearing... Found [%s] Element. Tried [%s] Times."
% (self.__name__, len(elements), t))
return False
def VerifyExistence(self, trueORfalse):
"""
EXAMPLE
Page.Element.VerifyExistence(True)
:param trueORfalse: True or False
:return:
"""
logger.step_normal("Element [%s]: Verify Existence = [%s]." % (self.__name__, trueORfalse))
if trueORfalse is True:
self.__wait_for_appearing()
else:
self.__wait_for_disappearing()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
logger.step_normal("Element [%s]: Count = [%s]" % (self.__name__, len(elements)))
if len(elements) > 0:
if trueORfalse is True:
logger.step_pass("Exist!")
else:
logger.step_fail("Exist!")
else:
if trueORfalse is False:
logger.step_pass("Not Exist!")
else:
logger.step_fail("Not Exist!")
def Refresh(self, times=4):
logger.step_normal("Element [%s]: Browser Refresh" % (self.__name__,))
for i in range(times):
action = webdriver.ActionChains(Browser.RunningBrowser)
action.key_down(Keys.CONTROL).send_keys(Keys.F5).key_up(Keys.CONTROL).perform()
time.sleep(5)
def cell(self, rowx, col_name):
for colx in range(0, self.ncols()):
if self.cellxy(0, colx) == col_name:
logger.step_normal("ExcelSheet.cellx(%s, %s)=[%s]" % (rowx, col_name, self.cellxy(rowx, colx)))
return self.cellxy(rowx, colx)
return None
def cell_by_colname(self, rowx, col_name):
for colx in range(0, self.sheet.ncols):
if self.data[0][colx] == col_name:
logger.step_normal("Excel Column [%s]=[%s]" % (col_name, self.data[rowx][colx]))
return self.data[rowx][colx]
return None
def cell_by_rowname(self, row_name, colx):
for rowx in range(0, self.sheet.nrows):
if self.data[rowx][0] == row_name:
logger.step_normal("Excel [row-name:%s, col:%s]=[%s]" % (row_name, colx, self.data[rowx][colx]))
return self.data[rowx][colx]
return None
def cell(self, rowx, col_name):
for colx in range(0, self.ncols()):
if self.cellxy(0, colx) == col_name:
logger.step_normal("ExcelSheet.cellx(%s, %s)=[%s]" %
(rowx, col_name, self.cellxy(rowx, colx)))
return self.cellxy(rowx, colx)
return None
def cell_by_colname(self, rowx, col_name):
for colx in range(0, self.sheet.ncols):
if self.data[0][colx] == col_name:
logger.step_normal("Excel Column [%s]=[%s]" %
(col_name, self.data[rowx][colx]))
return self.data[rowx][colx]
return None
def cell_by_rowname(self, row_name, colx):
for rowx in range(0, self.sheet.nrows):
if self.data[rowx][0] == row_name:
logger.step_normal("Excel [row-name:%s, col:%s]=[%s]" %
(row_name, colx, self.data[rowx][colx]))
return self.data[rowx][colx]
return None
def GetRepetitionWithoutWaiting(self):
""" Get real time obj counts, without waiting."""
logger.step_normal("Element [%s]: GetRepetitionWithoutWaiting()." % self.__name__)
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
logger.step_normal("Element [%s]: repetition = [%s]" % (self.__name__, len(elements)))
return len(elements)
def AlertSendKeys(self, value):
logger.step_normal("AlertSendKeys [%s]" % value)
try:
Browser.RunningBrowser.switch_to.alert.send_keys(value)
Browser.RunningBrowser.switch_to.default_content()
except Exception as e:
logger.step_normal(e)
logger.step_warning(str(sys.exc_info()))
def SwitchToDefaultContent(self):
logger.step_normal("SwitchToDefaultContent()")
try:
Browser.RunningBrowser.switch_to.default_content()
except Exception as e:
logger.step_normal(e)
logger.step_warning("Browser.RunningBrowser.switch_to.default_content()")
def AlertSendKeys(self, value):
logger.step_normal("AlertSendKeys [%s]" % value)
try:
Browser.RunningBrowser.switch_to.alert.send_keys(value)
Browser.RunningBrowser.switch_to.default_content()
except Exception as e:
logger.step_normal(e)
logger.step_warning(str(sys.exc_info()))
def Refresh(self, times=4):
logger.step_normal("Element [%s]: Browser Refresh" % (self.__name__, ))
for i in range(times):
action = webdriver.ActionChains(Browser.RunningBrowser)
action.key_down(Keys.CONTROL).send_keys(Keys.F5).key_up(
Keys.CONTROL).perform()
time.sleep(5)
def ReleaseClick(self):
logger.step_normal("Element [%s]: ReleaseClick()" % self.__name__)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
action = webdriver.ActionChains(Browser.RunningBrowser)
action.release(elements[self.index])
action.perform()
def ClickAndHold(self):
logger.step_normal("Element [%s]: ClickAndHold()" % self.__name__)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
action = webdriver.ActionChains(Browser.RunningBrowser)
action.click_and_hold(elements[self.index])
action.perform()
def cell_by_row_and_col_name(self, row_name, col_name):
for rowx in range(0, self.nrows()):
if self.cellxy(rowx, 0) == row_name:
logger.step_normal("Excel row_name=" + row_name +
", col_name=" + col_name + ", value=" +
self.cell(rowx, col_name))
return self.cell(rowx, col_name)
return None
def SwitchToDefaultContent(self):
logger.step_normal("SwitchToDefaultContent()")
try:
Browser.RunningBrowser.switch_to.default_content()
except Exception as e:
logger.step_normal(e)
logger.step_warning(
"Browser.RunningBrowser.switch_to.default_content()")
def ReleaseClick(self):
logger.step_normal("Element [%s]: ReleaseClick()" % self.__name__)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
action = webdriver.ActionChains(Browser.RunningBrowser)
action.release(elements[self.index])
action.perform()
def SendEnter(self):
logger.step_normal("Element [%s]: SendEnter()" % self.__name__, )
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
action = webdriver.ActionChains(Browser.RunningBrowser)
action.send_keys_to_element(elements[self.index], Keys.ENTER)
action.perform()
def TypeInWithoutClear(self, value):
"""Input value without clear existing values"""
logger.step_normal("Element [%s]: TypeInWithoutClear [%s]." % self.__name__, value)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
elements[self.index].send_keys(value)
def GetInnerHTML(self):
logger.step_normal("Element [%s]: GetInnerHTML()" % self.__name__)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
logger.step_normal("Element [%s]: InnerHTML = [%s]" % (self.__name__, elements[self.index].get_attribute('innerHTML')))
return elements[self.index].get_attribute('innerHTML')
def GetRepetition(self):
logger.step_normal("Element [%s]: GetRepetition()." % self.__name__)
self.__wait_for_appearing()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
logger.step_normal("Element [%s]: repetition = [%s]" % (self.__name__, len(elements)))
return len(elements)
def SendEnter(self):
logger.step_normal("Element [%s]: SendEnter()" % self.__name__, )
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
action = webdriver.ActionChains(Browser.RunningBrowser)
action.send_keys_to_element(elements[self.index], Keys.ENTER)
action.perform()
def ClickAndHold(self):
logger.step_normal("Element [%s]: ClickAndHold()" % self.__name__)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
action = webdriver.ActionChains(Browser.RunningBrowser)
action.click_and_hold(elements[self.index])
action.perform()
def AlertTextHave(self, txt_value):
logger.step_normal("AlertTextHave [%s]" % txt_value)
alert_text = Browser.RunningBrowser.switch_to_alert().text()
if txt_value in alert_text:
logger.step_pass("pass")
else:
logger.step_fail("fail")
Browser.RunningBrowser.switch_to_default_content()
def GetAttribute(self, attr):
logger.step_normal("Element [%s]: GetAttribute [%s]." % (self.__name__, attr))
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
attr_value = elements[self.index].get_attribute(attr)
logger.step_normal("Element [%s]: [%s] = [%s]." % (self.__name__, attr, attr_value))
return attr_value
def AlertTextHave(self, txt_value):
logger.step_normal("AlertTextHave [%s]" % txt_value)
alert_text = Browser.RunningBrowser.switch_to_alert().text()
if txt_value in alert_text:
logger.step_pass("pass")
else:
logger.step_fail("fail")
Browser.RunningBrowser.switch_to_default_content()
def GetRepetitionWithoutWaiting(self):
""" Get real time obj counts, without waiting."""
logger.step_normal("Element [%s]: GetRepetitionWithoutWaiting()." %
self.__name__)
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
logger.step_normal("Element [%s]: repetition = [%s]" %
(self.__name__, len(elements)))
return len(elements)
def GetRepetition(self):
logger.step_normal("Element [%s]: GetRepetition()." % self.__name__)
self.__wait_for_appearing()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
logger.step_normal("Element [%s]: repetition = [%s]" %
(self.__name__, len(elements)))
return len(elements)
def TypeInWithoutClear(self, value):
"""Input value without clear existing values"""
logger.step_normal(
"Element [%s]: TypeInWithoutClear [%s]." % self.__name__, value)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
elements[self.index].send_keys(value)
def VerifyAttribute(self, attribute, value, assertion='equal'):
"""
Example:
NewClaim.Dates.ReminderDate.VerifyAttribute('ng-model', 'hello', assertion='equal')
NewClaim.Dates.ReminderDate.VerifyAttribute('ng-model', 'hello', assertion='contain')
NewClaim.Dates.ReminderDate.VerifyAttribute('ng-model', 'hello', assertion='in')
NewClaim.Dates.ReminderDate.VerifyAttribute('ng-model', 'hello', assertion='not equal')
:param assertion:
in => Real value [in] 'hello'. For example: real_value is 'he'
equal => Real value [equal] 'hello'. For example: real_value is 'hello'
contain => Real value [contain] 'hello'. For example: real_value is 'hello world'.
not equal => Real value [not equal] 'hello'. For example: real_value is 'hallow'
not contain => Real value [not contain] 'hello'. For example: real_value is 'hi world'.
"""
logger.step_normal("Element [%s]: VerifyAttribute [%s] <%s> [%s]." %
(self.__name__, attribute, assertion, value))
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
real_value = elements[self.index].get_attribute(attribute)
if assertion.lower() == 'equal':
if value == real_value:
logger.step_pass("real value=[%s]" % real_value)
else:
logger.step_fail("real value=[%s]" % real_value)
elif assertion.lower() == 'not equal':
if not value == real_value:
logger.step_pass("real value=[%s]" % real_value)
else:
logger.step_fail("real value=[%s]" % real_value)
elif assertion.lower() == 'contain':
if value in real_value:
logger.step_pass("real value=[%s]" % real_value)
else:
logger.step_fail("real value=[%s]" % real_value)
elif assertion.lower() == 'not contain':
if not value in real_value:
logger.step_pass("real value=[%s]" % real_value)
else:
logger.step_fail("real value=[%s]" % real_value)
elif assertion.lower() == 'in':
if real_value in value:
logger.step_pass("real value=[%s]" % real_value)
else:
logger.step_fail("real value=[%s]" % real_value)
else:
logger.step_fail("code error.")
def GetInnerHTML(self):
logger.step_normal("Element [%s]: GetInnerHTML()" % self.__name__)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
logger.step_normal(
"Element [%s]: InnerHTML = [%s]" %
(self.__name__, elements[self.index].get_attribute('innerHTML')))
return elements[self.index].get_attribute('innerHTML')
def GetAttribute(self, attr):
logger.step_normal("Element [%s]: GetAttribute [%s]." %
(self.__name__, attr))
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
attr_value = elements[self.index].get_attribute(attr)
logger.step_normal("Element [%s]: [%s] = [%s]." %
(self.__name__, attr, attr_value))
return attr_value
def IsExist(self):
logger.step_normal("Element [%s]: IsExist?" % self.__name__)
time.sleep(2)
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
logger.step_normal("Element [%s]: IsExist? Count = [%s]" % (self.__name__, len(elements)))
if len(elements) > 0:
return True
else:
return False
def VerifyAttribute(self, attribute, value, assertion='equal'):
"""
Example:
NewClaim.Dates.ReminderDate.VerifyAttribute('ng-model', 'hello', assertion='equal')
NewClaim.Dates.ReminderDate.VerifyAttribute('ng-model', 'hello', assertion='contain')
NewClaim.Dates.ReminderDate.VerifyAttribute('ng-model', 'hello', assertion='in')
NewClaim.Dates.ReminderDate.VerifyAttribute('ng-model', 'hello', assertion='not equal')
:param assertion:
in => Real value [in] 'hello'. For example: real_value is 'he'
equal => Real value [equal] 'hello'. For example: real_value is 'hello'
contain => Real value [contain] 'hello'. For example: real_value is 'hello world'.
not equal => Real value [not equal] 'hello'. For example: real_value is 'hallow'
not contain => Real value [not contain] 'hello'. For example: real_value is 'hi world'.
"""
logger.step_normal("Element [%s]: VerifyAttribute [%s] <%s> [%s]." % (self.__name__, attribute, assertion, value))
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
real_value = elements[self.index].get_attribute(attribute)
if assertion.lower() == 'equal':
if value == real_value:
logger.step_pass("real value=[%s]" % real_value)
else:
logger.step_fail("real value=[%s]" % real_value)
elif assertion.lower() == 'not equal':
if not value == real_value:
logger.step_pass("real value=[%s]" % real_value)
else:
logger.step_fail("real value=[%s]" % real_value)
elif assertion.lower() == 'contain':
if value in real_value:
logger.step_pass("real value=[%s]" % real_value)
else:
logger.step_fail("real value=[%s]" % real_value)
elif assertion.lower() == 'not contain':
if not value in real_value:
logger.step_pass("real value=[%s]" % real_value)
else:
logger.step_fail("real value=[%s]" % real_value)
elif assertion.lower() == 'in':
if real_value in value:
logger.step_pass("real value=[%s]" % real_value)
else:
logger.step_fail("real value=[%s]" % real_value)
else:
logger.step_fail("code error.")
def MouseOver(self):
logger.step_normal("Element [%s]: MouseOver()" % self.__name__)
time.sleep(1)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
action = webdriver.ActionChains(Browser.RunningBrowser)
action.move_to_element(elements[self.index])
action.perform()
time.sleep(1)
def DragAndDropByOffset(self, xoffset, yoffset):
"""
Holds down the left mouse button on the source element,
then moves to the target offset and releases the mouse button.
"""
logger.step_normal("Element [%s]: drag_and_drop_by_offset()" % self.__name__)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
action = webdriver.ActionChains(Browser.RunningBrowser)
action.drag_and_drop_by_offset(elements[self.index],xoffset, yoffset)
action.perform()
def ScrollIntoView(self):
logger.step_normal("Element [%s]: ScrollToView()" % self.__name__)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
i = 0
while not elements[self.index].is_displayed():
WebBrowser.ScrollTo(0, i)
i = i + 10
if i == 1000:
logger.step_normal("still not displayed. break out.")
def Click(self):
logger.step_normal("Element [%s]: Click()" % self.__name__)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
try:
elements[self.index].click()
except ElementClickInterceptedException:
self.Wait(3)
action = webdriver.ActionChains(Browser.RunningBrowser)
action.click(elements[self.index])
action.perform()
def MouseOver(self):
logger.step_normal("Element [%s]: MouseOver()" % self.__name__)
time.sleep(1)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
action = webdriver.ActionChains(Browser.RunningBrowser)
action.move_to_element(elements[self.index])
action.perform()
time.sleep(1)
def IsExist(self):
logger.step_normal("Element [%s]: IsExist?" % self.__name__)
time.sleep(2)
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
logger.step_normal("Element [%s]: IsExist? Count = [%s]" %
(self.__name__, len(elements)))
if len(elements) > 0:
return True
else:
return False
def Click(self):
logger.step_normal("Element [%s]: Click()" % self.__name__)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
try:
elements[self.index].click()
except ElementClickInterceptedException:
self.Wait(3)
action = webdriver.ActionChains(Browser.RunningBrowser)
action.click(elements[self.index])
action.perform()
def ScrollIntoView(self):
logger.step_normal("Element [%s]: ScrollToView()" % self.__name__)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
i = 0
while not elements[self.index].is_displayed():
WebBrowser.ScrollTo(0, i)
i = i + 10
if i == 1000:
logger.step_normal("still not displayed. break out.")
def DragAndDropByOffset(self, xoffset, yoffset):
"""
Holds down the left mouse button on the source element,
then moves to the target offset and releases the mouse button.
"""
logger.step_normal("Element [%s]: drag_and_drop_by_offset()" %
self.__name__)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
action = webdriver.ActionChains(Browser.RunningBrowser)
action.drag_and_drop_by_offset(elements[self.index], xoffset, yoffset)
action.perform()
def __wait_for_enabled(self):
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
if elements[self.index].is_enabled():
return
else:
t = 0
while t < 90:
if elements[self.index].is_enabled():
break
logger.step_normal("Element [%s]: __wait_for_enabled for 1 second, By [%s :: %s :: %s]" %
(self.__name__, self.by, self.value, self.index))
time.sleep(1)
def __wait_for_enabled(self):
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
if elements[self.index].is_enabled():
return
else:
t = 0
while t < 90:
if elements[self.index].is_enabled():
break
logger.step_normal(
"Element [%s]: __wait_for_enabled for 1 second, By [%s :: %s :: %s]"
% (self.__name__, self.by, self.value, self.index))
time.sleep(1)
def Set(self, value):
logger.step_normal("Element [%s]: Set [%s]." % (self.__name__, value))
value = str(value)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
if elements[self.index].tag_name == "select" or elements[
self.index].tag_name == "ul":
self.Select(value)
else:
elements[self.index].clear()
elements[self.index].send_keys(value)
"""
def Set(self, value):
logger.step_normal("Element [%s]: Set [%s]." % (self.__name__, value))
value = str(value)
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
if elements[self.index].tag_name == "select" or elements[self.index].tag_name == "ul":
self.Select(value)
else:
elements[self.index].clear()
elements[self.index].send_keys(value)
"""
def AlertDismiss(self):
logger.step_normal("AlertDismiss()")
time.sleep(2)
try:
logger.step_normal("switch_to_alert()")
alert = Browser.RunningBrowser.switch_to_alert()
alert.dismiss()
except NoAlertPresentException:
logger.step_normal("Alert Not Found.")
try:
logger.step_normal("switch_to_default_content()")
Browser.RunningBrowser.switch_to_default_content()
except Exception as e:
logger.step_normal(e)
pass
def AlertDismiss(self):
logger.step_normal("AlertDismiss()")
time.sleep(2)
try:
logger.step_normal("switch_to_alert()")
alert = Browser.RunningBrowser.switch_to_alert()
alert.dismiss()
except NoAlertPresentException:
logger.step_normal("Alert Not Found.")
try:
logger.step_normal("switch_to_default_content()")
Browser.RunningBrowser.switch_to_default_content()
except Exception as e:
logger.step_normal(e)
pass
def VerifyVisible(self, trueORfalse):
logger.step_normal("Element [%s]: Verify Visible = [%s]." % (self.__name__, trueORfalse))
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
logger.step_normal("Element [%s]: Count = [%s]" % (self.__name__, len(elements)))
if elements[self.index].is_displayed():
if trueORfalse is True:
logger.step_pass("Visible!")
else:
logger.step_fail("Visible!")
else:
if trueORfalse is False:
logger.step_pass("Not Visible!")
else:
logger.step_fail("Not Visible!")
def VerifyVisible(self, trueORfalse):
logger.step_normal("Element [%s]: Verify Visible = [%s]." %
(self.__name__, trueORfalse))
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
logger.step_normal("Element [%s]: Count = [%s]" %
(self.__name__, len(elements)))
if elements[self.index].is_displayed():
if trueORfalse is True:
logger.step_pass("Visible!")
else:
logger.step_fail("Visible!")
else:
if trueORfalse is False:
logger.step_pass("Not Visible!")
else:
logger.step_fail("Not Visible!")
def __wait(self):
t = 0
while t < 300:
t = t + 1
try:
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
except NoSuchElementException:
logger.step_normal("Element [%s]: NoSuchElementException." % self.__name__)
elements = []
except UnexpectedAlertPresentException:
logger.step_warning("Element [%s]: UnexpectedAlertPresentException." % self.__name__)
if len(elements) == 0:
time.sleep(1)
logger.step_normal("Element [%s]: Wait 1 second, By [%s :: %s :: %s]" % (self.__name__,
self.by,
self.value,
self.index))
else:
if len(elements) > 1:
logger.step_normal("Element [%s]: There are [%s] Elements!" % (self.__name__, len(elements)))
break
if len(elements) < self.index + 1:
logger.step_fail("Element [%s]: Element Index Issue! There are [%s] Elements! Index=[%s]" % (self.__name__,
len(elements),
self.index))
def IsAttribute(self, attribute, value, assertion="contain"):
logger.step_normal("Element [%s]: IsAttribute [%s] <%s> [%s]?" % (self.__name__, attribute, assertion, value))
self.__wait()
elements = Browser.RunningBrowser.find_elements(self.by, self.value)
real_value = elements[self.index].get_attribute(attribute)
result = False
if assertion.lower() == 'equal' and value == real_value:
result = True
elif assertion.lower() == 'not equal' and value != real_value:
result = True
elif assertion.lower() == 'contain' and value in real_value:
result = True
elif assertion.lower() == 'not contain' and value not in real_value:
result = True
elif assertion.lower() == 'in' and real_value in value:
result = True
else:
logger.step_fail("code error.")
if result is True:
logger.step_normal("Yes!")
else:
logger.step_normal("No!")
return result
