def newBrowser(remoteClient, browserType, logdir, browserWait=15):
browser = None
# Internet Explore
if browserType in ["ie", "ie8", "ie9"]:
browser = QuestWebDriver("http://{}:4444/wd/hub".format(remoteClient), webdriver.DesiredCapabilities.INTERNETEXPLORER)
#browser = webdriver.Remote("http://{}:4444/wd/hub".format(remoteClient), webdriver.DesiredCapabilities.INTERNETEXPLORER)
# HTML Util
elif browserType == "hu":
# Original webdriver way
# browser = webdriver.Remote("http://{}:4444/wd/hub".format(remoteClient), webdriver.DesiredCapabilities.HTMLUNIT)
browser = QuestWebDriver("http://{}:4444/wd/hub".format(remoteClient), webdriver.DesiredCapabilities.HTMLUNIT)
# Google Chrome
elif browserType == "ch":
browser = QuestWebDriver("http://{}:4444/wd/hub".format(remoteClient), webdriver.DesiredCapabilities.CHROME)
# Firefox - Default if nothing is specified
else:
browser = QuestWebDriver("http://{}:4444/wd/hub".format(remoteClient), webdriver.DesiredCapabilities.FIREFOX)
browser.implicitly_wait(browserWait)
browser.delete_all_cookies()
browser.set_window_size(1280, 1024)
return browser
class browser(object):
#----------------------------------------------------------------------
def __init__(self, remoteClient, mcu_server, browserType, logdir, logger, browserWait=15):
self.browserType = browser
self.logger = logger
self.screenshotDir = logdir
self.browserWait = browserWait
self.page = None
self.element = None
self.mcu_server = mcu_server
try:
# Internet Explore
if browserType in ["ie", "ie8", "ie9"]:
self.page = QuestWebDriver("http://{}:4444/wd/hub".format(remoteClient), webdriver.DesiredCapabilities.INTERNETEXPLORER)
self.browserType = 'ie'
# HTML Util
elif browserType == "hu":
self.page = QuestWebDriver("http://{}:4444/wd/hub".format(remoteClient), webdriver.DesiredCapabilities.HTMLUNIT)
self.browserType = 'hu'
# Google Chrome
elif browserType == "ch":
self.page = QuestWebDriver("http://{}:9515".format(remoteClient), webdriver.DesiredCapabilities.CHROME)
self.browserType = 'ch'
# Firefox - Default if nothing is specified
else:
self.page = QuestWebDriver("http://{}:4444/wd/hub".format(remoteClient), webdriver.DesiredCapabilities.FIREFOX)
self.page.implicitly_wait(browserWait)
self.page.delete_all_cookies()
# Resize the browser. I have to shrink it first then move it to the corner then enlarge it.
self.page.set_window_size(800, 600)
self.page.set_window_position(0, 0)
self.page.set_window_size(1280, 1024)
self.mouse = webdriver.ActionChains(self.page)
# Get the Default window name
self.currentWindowHandle = self.page.current_window_handle
except:
self.logger.error("\n======================================================================")
self.logger.error("\nUnable to open connection to remote web browser on: {}".format(remoteClient))
self.logger.error("Check to make sure selenium is loaded on host: {}.".format(remoteClient))
self.logger.error("\n======================================================================\n")
#----------------------------------------------------------------------
def _findElements(self, elementID, message, findBy="id", returnAllItems=False, ignoreErrorMessage=False, isVisible=True, browserWait=None):
if findBy == "id":
element = self.page.find_elements_by_id(elementID)
elif findBy == "xpath":
element = self.page.find_elements_by_xpath(elementID)
elif findBy == "class":
element = self.page.find_elements_by_class_name(elementID)
return self.verifyElement(element, message, elementID, ignoreErrorMessage)
#----------------------------------------------------------------------
def _findElement(self, elementID, message, findBy="id", ignoreErrorMessage=False, isVisible=True, browserWait=None):
if findBy == "id":
element = self.page.find_element_by_id(elementID)
elif findBy == "xpath":
element = self.page.find_element_by_xpath(elementID)
elif findBy == "class":
element = self.page.find_element_by_class_name(elementID)
element = self.verifyElement(element, message, elementID, ignoreErrorMessage)
self.element = element
if element != False:
if isVisible:
check = self.isDisplayed(element)
else:
check = self.shouldNotBeDisplayed(element)
if check:
return element
return False
#----------------------------------------------------------------------
def findElement(self, elementID, message, findBy="id", returnAllItems=False, ignoreErrorMessage=False, isVisible=True, browserWait=None):
'''Finds the element based on xpath, id or class and returns the found element'''
try:
self.logger.info("")
if browserWait is None:
browserWait = 15
self.page.implicitly_wait(browserWait)
if not ignoreErrorMessage:
self.logger.info("Finding | {} using {}: {}".format(message, findBy, elementID))
else:
self.logger.info("Looking for {} using {}: {} \nWe are ignoring error messages for this element. Element may not/or should not exist at this point".format(message, findBy, elementID))
if returnAllItems:
return self._findElements(elementID, message, findBy, returnAllItems, ignoreErrorMessage, isVisible, browserWait)
else:
return self._findElement(elementID, message, findBy, ignoreErrorMessage, isVisible, browserWait)
except selenium.common.exceptions.NoSuchElementException:
self.logger.error("No such element! Could not find {}".format(message))
if not ignoreErrorMessage:
raise webdriverElementNotFound(message)
#raise mcuTest.webdriverElementNotFound(message)
return False
except selenium.common.exceptions.ElementNotVisibleException:
self.logger.error("Element is not visible! Could not find {}".format(message))
if not ignoreErrorMessage:
raise webdriverElementNotFound(message)
#raise mcuTest.webdriverElementNotFound(message)
return False
#----------------------------------------------------------------------
def verifyElement(self, element, elementDiscription, elementID, ignoreErrorMessage):
if element != [] or element != None:
self.logger.info("ELEMENT FOUND | {}".format(elementDiscription))
return element
#----------------------------------------------------------------------
def findElementWithObject(self, client, elementID, browserWait=None):
if browserWait is None:
browserWait = 15
self.page.implicitly_wait(browserWait)
self.logger.info("Finding for {} using - xpath={}".format(client, elementID))
hosts = self.page.find_elements_by_xpath(elementID)
if hosts != []:
for host in hosts:
if host.text == client:
return host
return False
#----------------------------------------------------------------------
def openWebPage(self, webPage):
# We need to wait for the server to come up. This could take a minute
tries = 1
result = False
self.logger.info("Opening webpage | {}".format(webPage))
self.page.get(webPage)
while tries < 20:
if self._pageReady(tries):
break
tries+=1
if tries > 10:
self.logger.info("Trying to open webpage again")
self.page.get(webPage)
#----------------------------------------------------------------------
def _pageReady(self, tries):
self.logger.info("\nAttempt {} of 20 | Checking to see if page is loaded...".format(tries))
self.logger.info("Current Page Title | {}".format(self.page.title))
if self.page.title in ["Problem loading page", "Unable to connect", "about:blank",
"Internet Explorer cannot display the webpage", "", "This page can't be displayed"]:
self.logger.warn("Page not ready yet refreshing page, please stand by...")
time.sleep(5)
# clear cookies and refresh. The browser was getting in a funny state, so I needed to clear cookies.
self.page.delete_all_cookies()
self.page.refresh()
return False
return True
#----------------------------------------------------------------------
def validateWebPage(self, pageExpected):
currentURL = self.page.current_url
#if pageExpected not in currentURL
newrl = currentURL.replace("?v=1", "")
if newrl.find(pageExpected) > -1:
return True
else:
if newrl == None:
newrl = "none"
self.logger.error('[!] Was expecting "{}", Got "{}" [!]'.format(pageExpected, newrl))
self._takeScreenShot(self.screenshotDir, "Webpage")
# Change this back to false. For now I am changing it so tests move on.
return False
return True
#----------------------------------------------------------------------
def compareText(self, element, expectedText):
try:
assert element.text == expectedText
except AssertionError:
self.logger.error('[!] Was expecting {}, Got {} [!]'.format(expectedText, element.text))
self.screenShot()
#----------------------------------------------------------------------
def isDisplayed(self, element):
try:
if not element.is_displayed():
self.logger.error('Element should be visible')
except AttributeError:
self.logger.error('[!] Element should be visable [!]')
return False
return True
#----------------------------------------------------------------------
def shouldNotBeDisplayed(self, element):
try:
if element.is_displayed():
self.logger.error('Element should not be visable')
except AttributeError:
self.logger.error('[!] Element should NOT be visable [!]')
return False
return True
#----------------------------------------------------------------------
def _takeScreenShot(self, screenDirectory="/tmp", elementDiscription="", screenType="base64"):
# Format the Name
screenCaptureName = elementDiscription.replace(" ", "")
screenCaptureName = screenCaptureName.replace(":", "")
screenCaptureName = "{}.png".format(screenCaptureName)
if screenType == "base64":
return self._takeScreenShotAsBase64(screenCaptureName, screenDirectory, elementDiscription)
else:
return self._takeScreenShotAsFile(screenCaptureName, screenDirectory, elementDiscription)
#----------------------------------------------------------------------
def _takeScreenShotAsFile(self, screenDirectory, elementDiscription):
if self.page.get_screenshot_as_file("{}/{}".format(screenDirectory, screenCaptureName)):
#self.logger.screenShot("./{}".format(screenCaptureName))
print "taking screenshot"
else:
self.logger.error('[o] Failed to take screenshot [o]')
#----------------------------------------------------------------------
def _takeScreenShotAsBase64(self, screenCaptureName, screenDirectory, elementDiscription):
b64 = self.page.get_screenshot_as_base64()
if b64:
# Need to pass this up to the logger.
decoded = base64.decodestring(b64)
return screenCaptureName, decoded, "image/png"
else:
self.logger.error('[o] Failed to take screenshot [o]')
#----------------------------------------------------------------------
def verifyClick(self, function):
element = function
try:
if not element:
return False
assert element is not None
element.click()
except AssertionError:
self.logger.error('Failed to find element')
return False
return True
#----------------------------------------------------------------------
def closeOtherOpenWindows(self):
# Get the list of open windows
openWindows = self.page.window_handles
if len(openWindows) > 1:
for window in openWindows:
if window != self.currentWindowHandle:
# Switch to that window
self.page.switch_to_window(window)
# Close the window
self.logger.info("Closing page: {}".format(self.page.title))
self.page.close()
else:
if self.page.current_window_handle != self.currentWindowHandle:
self.logger.error("The original window does not have focus and there is only one window open")
self.screenShot()
# Set focus back to main window
self.page.switch_to_window(self.currentWindowHandle)
self.logger.info("Switching back parent window: {}".format(self.page.title))
#----------------------------------------------------------------------
def screenShot(self, bugNumber=None):
"""
This will take a screen capture and set a failure in slick
"""
if bugNumber != None:
self.logger.error('Please see <a style="color:red;" href="https://slcbugl01.prod.quest.corp/show_bug.cgi?id={}">BUG {}</a> for details'.format(bugNumber, bugNumber))
screenCaptureName, data, mimeType = self._takeScreenShot(elementDiscription=time.strftime('%Y_%m_%d %H:%M'))
raise takeScreenCapture(screenCaptureName, data, mimeType)