Python webdriver.WTF_WEBDRIVER_MANAGER类代码示例

 def tearDown(self):
     "This tear down will close the current allocated webdriver"
     
     # do_and_ignore() is a handle wrapper that let's you run a statement 
     # and not care if it errors or not.  This is helpful for tearDown
     # routines where the success/failure is not part of the test result.
     do_and_ignore(lambda: WTF_WEBDRIVER_MANAGER.close_driver())

 def test_create_page_handles_pageobject_with_no_validation(self):
     self.driver = WTF_WEBDRIVER_MANAGER.new_driver(
         "TestPageFactory.test_create_page_handles_pageobject_with_no_validation")
     self.assertRaises(TypeError,
                       PageFactory.create_page,
                       ValidateNotImplementedPageObject,
                       self.driver)

    def __init__(self, webdriver=None, max_time=WTF_TIMEOUT_MANAGER.EPIC, sleep=5, **kwargs):
        """
        Constructor

        Kwargs:
            webdriver (WebDriver) - Selenium Webdriver instance
            max_time (number) - Maximum wait time to keep the browser on stand by.
            sleep (number) - Number of seconds to wait between sending heart beats.

        """
        if webdriver is None:
            webdriver = WTF_WEBDRIVER_MANAGER.get_driver()

        self.webdriver = webdriver
        self._sleep_time = sleep
        self._max_time = max_time

        # This is used by the shortcut method 'start_standby', which is used 
        # with the 'with' statement.
        self._autostart = False
        try:
            if kwargs['_autostart']:
                self._autostart = True
        except KeyError:
            pass

 def test_create_page_uses_page_rank(self):
     self.driver = WTF_WEBDRIVER_MANAGER.new_driver(
         "TestPageFactory.test_create_page_uses_page_rank")
     self.driver.get("http://www.google.com")
     google_page = PageFactory.create_page(
         [GoogleSearch, GoogleSearch2], self.driver)
     self.assertTrue(isinstance(google_page, GoogleSearch2))

 def test_create_page_with_list(self):
     self.driver = WTF_WEBDRIVER_MANAGER.new_driver("TestPageFactor.test_create_page_with_list")
     self.driver.get("http://www.google.com")
     google = PageFactory.create_page([GoogleSearch, YahooSearch], self.driver)
     self.assertTrue(type(google) == GoogleSearch)
     self.driver.get("http://www.yahoo.com")
     yahoo = PageFactory.create_page([GoogleSearch, YahooSearch], self.driver)
     self.assertTrue(type(yahoo) == YahooSearch)

 def test_create_page_createsPageWhenExists(self):
     self.driver = WTF_WEBDRIVER_MANAGER.new_driver(
         "TestPageFactory.test_create_page_createsPageWhenExists")
     self.driver.get("http://www.google.com")
     google = PageFactory.create_page(SearchPage, self.driver)
     self.assertTrue(type(google) == GoogleSearch)
     self.driver.get("http://www.yahoo.com")
     yahoo = PageFactory.create_page(SearchPage, self.driver)
     self.assertTrue(type(yahoo) == YahooSearch)

 def create_page(cls, webdriver=None, **kwargs):
     """
     Class method short cut to call PageFactory on itself.
     @param webdriver: WebDriver to associate with this page.
     @type webdriver: WebDriver
     """
     if not webdriver:
         webdriver = WTF_WEBDRIVER_MANAGER.get_driver()
     return PageFactory.create_page(cls, webdriver=webdriver, **kwargs)

 def test_using_flows(self):
     """
     Demonstrate abstracting out several steps into 1 call into a flow
     
     Let's say we have 2 or 3 steps that are repeated over and over again.
     Then it's a good idea to make it a workflow ('flow'), that can be 
     reused between different tests.
     """
     webdriver = WTF_WEBDRIVER_MANAGER.new_driver()
     search_page = perform_search("hello world", webdriver)
     self.assertTrue(search_page.result_contains("hello world"))

 def test_createPage_createsPageFromFactory(self):
     # Mock a webdriver that looks like it's viewing yahoo
     config_reader = mock()
     when(config_reader).get("selenium.take_reference_screenshot", False).thenReturn(False)
     
     self.driver = WTF_WEBDRIVER_MANAGER.new_driver("TestPageObject.test_createPage_createsPageFromFactory")
     self.driver.get("http://www.google.com")
     google = SearchPage.create_page(self.driver, config_reader=config_reader)
     self.assertTrue(type(google) == GoogleSearch)
     self.driver.get("http://www.yahoo.com")
     yahoo = SearchPage.create_page(self.driver, config_reader=config_reader)
     self.assertTrue(type(yahoo) == YahooSearch)

    def test_example_using_abstract_interfaces(self):
        "Demonstrates creating PageObjects using Abstract Factory pattern."
        webdriver = WTF_WEBDRIVER_MANAGER.new_driver()
        webdriver.get("http://www.google.com")

        # Notice I don't need specify GoogleSearchPage specifically, and
        # able to construct a ISearchPage of the correct type.
        search_page = PageFactory.create_page(ISearchPage, webdriver)
        self.assertEqual(GoogleSearchPage, type(search_page))

        webdriver.get("http://www.yahoo.com")
        search_page = PageFactory.create_page(ISearchPage, webdriver)
        self.assertEqual(YahooSearchPage, type(search_page))

    def wait_until_page_loaded(page_obj_class,
                               webdriver=None,
                               timeout=WTF_TIMEOUT_MANAGER.NORMAL,
                               sleep=0.5,
                               bad_page_classes=[], **kwargs):
        """
        Waits until the page is loaded.
        
        Usage Example: 
            webdriver.get("http://www.mysite.com/login")
            # Wait up to 60 seconds for the page to load.
            login_page = wait_until_page_loaded(LoginPage, timeout=60)
        
        @return: Returns PageObject of type passed in.
        @rtype: PageObject
        """
        if not webdriver:
            webdriver = WTF_WEBDRIVER_MANAGER.get_driver()

        #convert this param to list if not already.
        if type(bad_page_classes) != list:
            bad_page_classes = [bad_page_classes]

        end_time = datetime.now() + timedelta(seconds=timeout)
        last_exception = None
        while datetime.now() < end_time:
            # Check to see if we're at our target page.
            try:
                page = PageFactory.create_page(page_obj_class, webdriver=webdriver, **kwargs)
                PageUtils.wait_until_page_ready(page)
                return page
            except Exception as e:
                last_exception = e
                pass
                # Check to see if we're at one of those labled 'Bad' pages.
            for bad_page_class in bad_page_classes:
                try:
                    PageFactory.create_page(bad_page_class, webdriver=webdriver, **kwargs)
                    #if the if/else statement succeeds, than we have an error.
                    raise BadPageEncounteredError("Encountered a bad page. " + bad_page_class.__name__)
                except BadPageEncounteredError as e:
                    raise e
                except:
                    pass #We didn't hit a bad page class yet.
                #sleep till the next iteration.
            time.sleep(sleep)

        print "Unable to construct page, last exception", last_exception
        raise PageLoadTimeoutError("Timedout while waiting for {page} to load. Url:{url}". \
            format(page=PageUtils.__get_name_for_class__(page_obj_class),
                   url=webdriver.current_url))

 def test_home_page_basic(self):
     webdriver = WTF_WEBDRIVER_MANAGER.new_driver()
     webdriver.get(ConfigReader('site_credentials').get("default_url"))
     home_page = PageFactory.create_page(HomePage, webdriver)
     home_page.search_for_what(u"Бар")
     home_page.search_for_where(u"Москва")
     home_page.click_search_button()
     webdriver.implicitly_wait(3000)
     results_list_page = PageFactory.create_page(ResultsList, webdriver)
     self.assertEqual(webdriver.title, "Localway")
     category = results_list_page.category_filter_list()
     category_path = PageUtils.get_element_xpath(category)
     print category_path
     print('test ok')

 def test_capture_file_created_and_valid_png(self):
     self.driver = WTF_WEBDRIVER_MANAGER.new_driver("TestPageUtils.test_capture_file_created_and_valid_png")
     self.driver.get("http://www.yahoo.com")
     fname = "test"
     prj_root = ProjectUtils.get_project_root()
     fpath = os.path.join(prj_root, WebScreenShotUtil.SCREEN_SHOT_LOCATION, fname + ".png")
     try:
         WebScreenShotUtil.take_screenshot(self.driver, fname)
         self.assertTrue(os.path.isfile(fpath))
         self.assertEquals(imghdr.what(fpath), "png")
     finally:
         try:
             os.remove(fpath)
         except OSError:
             pass

    def test_wait_for_page_to_load(self):
        self.driver = WTF_WEBDRIVER_MANAGER.new_driver("TestPageUtils.test_wait_for_page_to_load")
        start_time = datetime.now()
        
        # create a separate thread to load yahoo 10 seconds later.
        t = threading.Thread(target=self.__load_google_later)
        t.start()

        self.page_obj = page.PageUtils.wait_until_page_loaded(GoogleSearch, self.driver, 60, sleep=5)
        t.join()
        end_time = datetime.now()
        
        # check we get a page object pack.
        self.assertTrue(isinstance(self.page_obj, GoogleSearch))
        # check that the instantiation happened later when the page was loaded.
        self.assertGreater(end_time - start_time, timedelta(seconds=10))

    def __init__(self, webdriver=None, max_time=WTF_TIMEOUT_MANAGER.EPIC, sleep=5):
        """
        Constructor

        Kwargs:
            webdriver (WebDriver) - Selenium Webdriver instance
            max_time (number) - Maximum wait time to keep the browser on stand by.
            sleep (number) - Number of seconds to wait between sending heart beats.

        """
        if webdriver is None:
            webdriver = WTF_WEBDRIVER_MANAGER.get_driver()

        self.webdriver = webdriver
        self._sleep_time = sleep
        self._max_time = max_time