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

    def create_page(cls, webdriver=None, **kwargs):
        """Class method short cut to call PageFactory on itself.  Use it to instantiate 
        this PageObject using a webdriver.

        Args:
            webdriver (Webdriver): Instance of Selenium Webdriver.

        Returns:
            PageObject

        Raises:
            InvalidPageError

        """
        if not webdriver:
            webdriver = WTF_WEBDRIVER_MANAGER.get_driver()
        return PageFactory.create_page(cls, webdriver=webdriver, **kwargs)

    def test_basic_example(self):
        "Displays a simple PageObject instantiation example."
        
        # WTF_WEBDRIVER_MANAGER provides a easy to access to 
        # the webdriver.  A web browser will be instantiated 
        # according to your config settings. 
        # - see 'selenium' settings in 'configs/default.yaml'
        webdriver = WTF_WEBDRIVER_MANAGER.new_driver()

        # Simple navigation
        webdriver.get("http://www.google.com")
        
        # Use the PageFactory class to instantiate your page.
        google_page = PageFactory.create_page(GoogleSearchPage, webdriver)
        
        # With your PageObject instantiated, you can call it's methods.
        google_page.search("hello world")
        
        self.assertTrue(google_page.result_contains("hello world"))

 def test_using_the_testdata(self):
     """
     Demonstrates getting a setting via testdata package, and WTF_CONFIG_READER
     
     By default it'll use google.com, but you can add this line in the config file 
     (by default it's default.yaml) You can override this setting.
     
     Insert the line below and run again to see this same test run in Yahoo.
     
         search_provider: http://www.yahoo.com
     
     By creating  testdata functions to abstract directly accessing WTF_CONFIG_READER, 
     we can reduce the number of hard coded strings that needs to be refactored if 
     configuration settings need to be refactored.
     """
     search_url = get_search_provider()
     webdriver = WTF_WEBDRIVER_MANAGER.new_driver()
     webdriver.get(search_url)
     search_page = PageFactory.create_page(ISearchPage, webdriver)
     search_page.search("hello world")
     self.assertTrue(search_page.result_contains("hello world"))

 def setUp(self):
     self.driver = WTF_WEBDRIVER_MANAGER.new_driver()
     self.base_url = WTF_CONFIG_READER.get("selenium.baseurl")

 def set_up(self):
     webdriver = WTF_WEBDRIVER_MANAGER.new_driver()
     webdriver.get(ConfigReader('site_credentials').get("default_url"))
     return webdriver