Python events.EventFiringWebDriver類代碼示例

    def test_demo(self):

        pjsdriver = webdriver.PhantomJS("phantomjs")
        d = EventFiringWebDriver(pjsdriver, ScreenshotListener())

        d.get("http://www.google.com")
        d.find_element_by_css_selector("div.that-does-not-exist")

class TestTacoTodos(object):

    def setup_method(self, method):
        self.driver = EventFiringWebDriver(remote_webdriver, MaListener())
        self.current_method_name = method.__name__

    def teardown_method(self, method):
        self.driver.close()
        self.driver.quit()

    def test_todo_counts(self):
        tacotodos = TacoTodoPage(self.driver).open()
        tacotodos.new_todo = 'Bean and egg taco \n'
        tacotodos.new_todo = 'Potato, egg & cheese \n'
        tacotodos.new_todo = 'Nopales y huevos\n'
        tacotodos.new_todo = 'Crispy taco\n'
        tacotodos.new_todo = 'Cruspy taco\n'
        tacotodos.new_todo = 'Crepes\n'
        assert 6 == tacotodos.todos_remaining
        tacotodos.complete_all_todos()
        assert 6 == tacotodos.todos_completed
        assert 6 == tacotodos.todos_listed
        assert 0 == tacotodos.todos_remaining
        tacotodos.clear_completed_todos()
        assert 0 == tacotodos.todos_listed
        assert 0 == tacotodos.todos_completed

 def test_should_unwrap_element_args_when_calling_scripts(self):
     ef_driver = EventFiringWebDriver(self.driver, AbstractEventListener())
     ef_driver.get(self._pageURL("javascriptPage"))
     button = ef_driver.find_element_by_id("plainButton")
     value = ef_driver.execute_script(
         "arguments[0]['flibble'] = arguments[0].getAttribute('id'); return arguments[0]['flibble']",
         button)
     self.assertEqual("plainButton", value)

 def test_should_unwrap_element_args_when_calling_scripts(self, driver, log, pages):
     ef_driver = EventFiringWebDriver(driver, AbstractEventListener())
     ef_driver.get(pages.url("javascriptPage.html"))
     button = ef_driver.find_element_by_id("plainButton")
     value = ef_driver.execute_script(
         "arguments[0]['flibble'] = arguments[0].getAttribute('id'); return arguments[0]['flibble']",
         button)
     assert "plainButton" == value

    def test_should_fire_navigation_events(self):
        log = self.log 
                
        class TestListener(AbstractEventListener):
            def before_navigate_to(self, url, driver):
                log.write(("before_navigate_to %s" % url.split("/")[-1]).encode())
            def after_navigate_to(self, url, driver):
                log.write(("after_navigate_to %s" % url.split("/")[-1]).encode())
            def before_navigate_back(self, driver):
                log.write(b"before_navigate_back")
            def after_navigate_back(self, driver):
                log.write(b"after_navigate_back")
            def before_navigate_forward(self, driver):
                log.write(b"before_navigate_forward")
            def after_navigate_forward(self, driver):
                log.write(b"after_navigate_forward")
            
        ef_driver = EventFiringWebDriver(self.driver, TestListener())            
        ef_driver.get(self._pageURL("formPage"))
        ef_driver.find_element(by=By.ID, value="imageButton").submit()
        self.assertEqual(ef_driver.title, "We Arrive Here")

        ef_driver.back()
        self.assertEqual(ef_driver.title, "We Leave From Here")

        ef_driver.forward()
        self.assertEqual(ef_driver.title, "We Arrive Here")        
       
        self.assertEqual(b"before_navigate_to formPage.html" \
                + b"after_navigate_to formPage.html" \
                + b"before_navigate_back" \
                + b"after_navigate_back" \
                + b"before_navigate_forward" \
                + b"after_navigate_forward", log.getvalue())

def test_missing_attributes_raise_error(driver, pages):
    ef_driver = EventFiringWebDriver(driver, AbstractEventListener())

    with pytest.raises(AttributeError):
        ef_driver.attribute_should_not_exist

    ef_driver.get(pages.url("readOnlyPage.html"))
    element = ef_driver.find_element_by_id("writableTextInput")

    with pytest.raises(AttributeError):
        element.attribute_should_not_exist

    def test_should_call_listener_when_an_exception_is_thrown(self, driver, log, pages):
        class TestListener(AbstractEventListener):
            def on_exception(self, exception, driver):
                if isinstance(exception, NoSuchElementException):
                    log.write(b"NoSuchElementException is thrown")

        ef_driver = EventFiringWebDriver(driver, TestListener())
        ef_driver.get(pages.url("simpleTest.html"))
        with pytest.raises(NoSuchElementException):
            ef_driver.find_element(By.ID, "foo")
        assert b"NoSuchElementException is thrown" == log.getvalue()

    def test_should_be_able_to_access_wrapped_instance_from_event_calls(self):
        driver = self.driver

        class TestListener(AbstractEventListener):
            def before_navigate_to(self, url, d):
                assert driver is d

        ef_driver = EventFiringWebDriver(driver, TestListener())
        wrapped_driver = ef_driver.wrapped_driver
        assert driver is wrapped_driver

        ef_driver.get(self._pageURL("simpleTest"))

    def test_should_fire_find_event(self, driver, log, pages):

        class TestListener(AbstractEventListener):

            def before_find(self, by, value, driver):
                log.write(("before_find by %s %s" % (by, value)).encode())

            def after_find(self, by, value, driver):
                log.write(("after_find by %s %s" % (by, value)).encode())

        ef_driver = EventFiringWebDriver(driver, TestListener())
        ef_driver.get(pages.url("simpleTest.html"))
        e = ef_driver.find_element_by_id("oneline")
        assert "A single line of text" == e.text

        e = ef_driver.find_element_by_xpath("/html/body/p[1]")
        assert "A single line of text" == e.text

        ef_driver.get(pages.url("frameset.html"))
        elements = ef_driver.find_elements_by_css_selector("frame#sixth")
        assert 1 == len(elements)
        assert "frame" == elements[0].tag_name.lower()
        assert "sixth" == elements[0].get_attribute("id")

        assert (b"before_find by id oneline"
                b"after_find by id oneline"
                b"before_find by xpath /html/body/p[1]"
                b"after_find by xpath /html/body/p[1]"
                b"before_find by css selector frame#sixth"
                b"after_find by css selector frame#sixth") == log.getvalue()

    def test_should_fire_click_event(self, driver, log, pages):
        class TestListener(AbstractEventListener):
            def before_click(self, element, driver):
                log.write(b"before_click")

            def after_click(self, element, driver):
                log.write(b"after_click")

        ef_driver = EventFiringWebDriver(driver, TestListener())
        ef_driver.get(pages.url("clicks.html"))
        ef_driver.find_element(By.ID, "overflowLink").click()
        assert ef_driver.title == "XHTML Test Page"

        assert b"before_click" + b"after_click" == log.getvalue()

    def test_should_fire_find_event(self):
        log = self.log

        class TestListener(AbstractEventListener):

            def before_find(self, by, value, driver):
                log.write(("before_find by %s %s" % (by, value)).encode())

            def after_find(self, by, value, driver):
                log.write(("after_find by %s %s" % (by, value)).encode())

        ef_driver = EventFiringWebDriver(self.driver, TestListener())
        ef_driver.get(self._pageURL("simpleTest"))
        e = ef_driver.find_element_by_id("oneline")
        self.assertEqual("A single line of text", e.text)

        e = ef_driver.find_element_by_xpath("/html/body/p[1]")
        self.assertEqual("A single line of text", e.text)

        ef_driver.get(self._pageURL("frameset"))
        elements = ef_driver.find_elements_by_css_selector("frame#sixth")
        self.assertEqual(1, len(elements))
        self.assertEqual("frame", elements[0].tag_name.lower())
        self.assertEqual("sixth", elements[0].get_attribute("id"))

        self.assertEqual(
            b"before_find by id oneline"
            b"after_find by id oneline"
            b"before_find by xpath /html/body/p[1]"
            b"after_find by xpath /html/body/p[1]"
            b"before_find by css selector frame#sixth"
            b"after_find by css selector frame#sixth", log.getvalue())

 def test_should_fire_click_event(self):
     log = self.log
     
     class TestListener(AbstractEventListener):            
         def before_click(self, element, driver):
             log.write(b"before_click")
         def after_click(self, element, driver):
             log.write(b"after_click")
         
     ef_driver = EventFiringWebDriver(self.driver, TestListener())            
     ef_driver.get(self._pageURL("clicks"))        
     ef_driver.find_element(By.ID, "overflowLink").click() 
     self.assertEqual(ef_driver.title, "XHTML Test Page")
     
     self.assertEqual(b"before_click" + b"after_click", log.getvalue())

    def test_should_call_listener_when_an_exception_is_thrown(self):
        log = self.log

        class TestListener(AbstractEventListener):
            def on_exception(self, exception, driver):
                if isinstance(exception, NoSuchElementException):
                    log.write(b"NoSuchElementException is thrown")

        ef_driver = EventFiringWebDriver(self.driver, TestListener())
        ef_driver.get(self._pageURL("simpleTest"))
        try:
            ef_driver.find_element(By.ID, "foo")
            self.fail("Expected exception to be propagated")
        except NoSuchElementException:
            pass
        self.assertEqual(b"NoSuchElementException is thrown", log.getvalue())

    def test_should_fire_change_value_event(self, driver, log, pages):

        class TestListener(AbstractEventListener):

            def before_change_value_of(self, element, driver):
                log.write(b"before_change_value_of")

            def after_change_value_of(self, element, driver):
                log.write(b"after_change_value_of")

        ef_driver = EventFiringWebDriver(driver, TestListener())
        ef_driver.get(pages.url("readOnlyPage.html"))
        element = ef_driver.find_element_by_id("writableTextInput")
        element.clear()
        assert "" == element.get_attribute("value")

        ef_driver.get(pages.url("javascriptPage.html"))
        keyReporter = ef_driver.find_element(by=By.ID, value="keyReporter")
        keyReporter.send_keys("abc def")
        assert keyReporter.get_attribute("value") == "abc def"

        assert (b"before_change_value_of"
                b"after_change_value_of"
                b"before_change_value_of"
                b"after_change_value_of") == log.getvalue()

    def test_should_fire_change_value_event(self):
        log = self.log

        class TestListener(AbstractEventListener):

            def before_change_value_of(self, element, driver):
                log.write(b"before_change_value_of")

            def after_change_value_of(self, element, driver):
                log.write(b"after_change_value_of")

        ef_driver = EventFiringWebDriver(self.driver, TestListener())
        ef_driver.get(self._pageURL("readOnlyPage"))
        element = ef_driver.find_element_by_id("writableTextInput")
        element.clear()
        self.assertEqual("", element.get_attribute("value"))

        ef_driver.get(self._pageURL("javascriptPage"))
        keyReporter = ef_driver.find_element(by=By.ID, value="keyReporter")
        keyReporter.send_keys("abc def")
        self.assertEqual(keyReporter.get_attribute("value"), "abc def")

        self.assertEqual(
            b"before_change_value_of"
            b"after_change_value_of"
            b"before_change_value_of"
            b"after_change_value_of", log.getvalue())