celerity_thingista 0.9.2

data/lib/celerity/short_inspect.rb

@@ -0,0 +1,29 @@
+module Celerity
+  module ShortInspect
+
+    def short_inspect(opts)
+      if excluded_ivars = opts[:exclude]
+        if is_ruby19
+          excluded_ivars.map! { |ivar| ivar.to_sym }
+        end
+        ivars = (instance_variables - excluded_ivars)
+      elsif included_ivars = opts[:include]
+        if is_ruby19
+          included_ivars.map! { |ivar| ivar.to_sym }
+        end
+        ivars = included_ivars
+      else
+        raise ArgumentError, "unknown arg: #{opts.inspect}"
+      end
+
+      ivars.map! { |ivar| "#{ivar}=#{instance_variable_get(ivar).inspect}" }
+      '#<%s:0x%s %s>' % [self.class.name, self.hash.to_s(16), ivars.join(" ")]
+    end
+
+    private
+    def is_ruby19
+      RUBY_VERSION >= "1.9"
+    end
+
+  end
+end

data/lib/celerity/util.rb

@@ -0,0 +1,129 @@
+module Celerity
+  module Util
+    module_function
+
+    HtmlUnit2CelerityElement = {
+      HtmlUnit::Html::HtmlAnchor                => Celerity::Link,
+      HtmlUnit::Html::HtmlArea                  => Celerity::Area,
+      HtmlUnit::Html::HtmlButton                => Celerity::Button,
+      HtmlUnit::Html::HtmlSubmitInput           => Celerity::Button,
+      HtmlUnit::Html::HtmlResetInput            => Celerity::Button,
+      HtmlUnit::Html::HtmlImageInput            => Celerity::Button,
+      HtmlUnit::Html::HtmlButtonInput           => Celerity::Button,
+      HtmlUnit::Html::HtmlCaption               => Celerity::Button, # ?
+      HtmlUnit::Html::HtmlCheckBoxInput         => Celerity::CheckBox,
+      HtmlUnit::Html::HtmlDefinitionDescription => Celerity::Dd,
+      HtmlUnit::Html::HtmlDefinitionList        => Celerity::Dl,
+      HtmlUnit::Html::HtmlDefinitionTerm        => Celerity::Dt,
+      HtmlUnit::Html::HtmlDeletedText           => Celerity::Del,
+      HtmlUnit::Html::HtmlDivision              => Celerity::Div,
+      HtmlUnit::Html::HtmlFileInput             => Celerity::FileField,
+      HtmlUnit::Html::HtmlForm                  => Celerity::Form,
+      HtmlUnit::Html::HtmlFrame                 => Celerity::Frame,
+      HtmlUnit::Html::HtmlHeading1              => Celerity::H1,
+      HtmlUnit::Html::HtmlHeading2              => Celerity::H2,
+      HtmlUnit::Html::HtmlHeading3              => Celerity::H3,
+      HtmlUnit::Html::HtmlHeading4              => Celerity::H4,
+      HtmlUnit::Html::HtmlHeading5              => Celerity::H5,
+      HtmlUnit::Html::HtmlHeading6              => Celerity::H6,
+      HtmlUnit::Html::HtmlHiddenInput           => Celerity::Hidden,
+      HtmlUnit::Html::HtmlImage                 => Celerity::Image,
+      HtmlUnit::Html::HtmlLabel                 => Celerity::Label,
+      HtmlUnit::Html::HtmlListItem              => Celerity::Li,
+      HtmlUnit::Html::HtmlMap                   => Celerity::Map,
+      HtmlUnit::Html::HtmlOption                => Celerity::Option,
+      HtmlUnit::Html::HtmlOrderedList           => Celerity::Ol,
+      HtmlUnit::Html::HtmlParagraph             => Celerity::P,
+      HtmlUnit::Html::HtmlPasswordInput         => Celerity::TextField,
+      HtmlUnit::Html::HtmlPreformattedText      => Celerity::Pre,
+      HtmlUnit::Html::HtmlRadioButtonInput      => Celerity::Radio,
+      HtmlUnit::Html::HtmlSelect                => Celerity::SelectList,
+      HtmlUnit::Html::HtmlSpan                  => Celerity::Span,
+      HtmlUnit::Html::HtmlTable                 => Celerity::Table,
+      HtmlUnit::Html::HtmlTableBody             => Celerity::TableBody,
+      HtmlUnit::Html::HtmlTableCell             => Celerity::TableCell,
+      HtmlUnit::Html::HtmlTableDataCell         => Celerity::TableCell,
+      HtmlUnit::Html::HtmlTableFooter           => Celerity::TableFooter,
+      HtmlUnit::Html::HtmlTableHeader           => Celerity::TableHeader,
+      HtmlUnit::Html::HtmlTableRow              => Celerity::TableRow,
+      HtmlUnit::Html::HtmlTextArea              => Celerity::TextField,
+      HtmlUnit::Html::HtmlTextInput             => Celerity::TextField,
+      HtmlUnit::Html::HtmlUnorderedList         => Celerity::Ul,
+      HtmlUnit::Html::HtmlInsertedText          => Celerity::Ins
+    }
+
+    def htmlunit2celerity(klass)
+      HtmlUnit2CelerityElement[klass]
+    end
+
+    #
+    # HtmlUnit will recognize most common file types, but custom ones can be added here.
+    # Used for FileField uploads.
+    #
+
+    ContentTypes = {
+      ".bmp" => "image/x-ms-bmp",
+      ".doc" => "application/msword",
+      ".odg" => "application/vnd.oasis.opendocument.graphics",
+      ".odp" => "application/vnd.oasis.opendocument.presentation",
+      ".ods" => "application/vnd.oasis.opendocument.spreadsheet",
+      ".odt" => "application/vnd.oasis.opendocument.text",
+      ".ppt" => "application/vnd.ms-powerpoint",
+      ".xls" => "application/vnd.ms-excel",
+    }
+
+    def content_type_for(path)
+      if ct = java.net.URLConnection.getFileNameMap.getContentTypeFor(path)
+        return ct
+      else
+        ContentTypes[File.extname(path).downcase]
+      end
+    end
+
+    def normalize_text(string)
+      string.gsub("\302\240", ' '). # non-breaking space 00A0
+             gsub(/\n|\t/, '').     # get rid of newlines/tabs
+             strip
+    end
+
+    def logger_for(package_string)
+      java.util.logging.Logger.getLogger(package_string)
+    end
+
+    # number of spaces that separate the property from the value in the create_string method
+    TO_S_SIZE = 14
+
+    def create_string(element)
+      ret = []
+
+      unless (tag = element.getTagName).empty?
+        ret << "tag:".ljust(TO_S_SIZE) + tag
+      end
+
+      element.getAttributes.each do |_, attribute|
+        ret << "  #{attribute.getName}:".ljust(TO_S_SIZE + 2) + attribute.getValue.to_s
+      end
+
+      unless (text = element.asText).empty?
+        ret << "  text:".ljust(TO_S_SIZE + 2) + element.asText
+      end
+
+      ret.join("\n")
+    end
+
+    #
+    # Used internally.
+    #
+    # @param [String] string The string to match against.
+    # @param [Regexp, String, #to_s] what The match we're looking for.
+    # @return [Fixnum, true, false, nil]
+    #
+    # @api private
+    #
+
+    def matches?(string, what)
+      Regexp === what ? string.strip =~ what : string == what.to_s
+    end
+
+  end
+end

data/lib/celerity/version.rb

@@ -0,0 +1,3 @@
+module Celerity
+  VERSION = "0.9.2"
+end

data/lib/celerity/viewer_connection.rb

@@ -0,0 +1,89 @@
+module Celerity
+  class ViewerConnection
+
+    #
+    # Create a new connection to the given host/port
+    #
+
+    def self.create(host, port)
+      # if the connection fails, we won't spend time loading json
+      socket = TCPSocket.new(host, port)
+      require "json"
+      new(socket)
+    end
+
+    def initialize(socket)
+      @socket = socket
+    end
+
+    #
+    # Tells the viewer to render the given HTML, with the given URL as base url.
+    #
+
+    def render_html(html, url)
+      send_data('method' => 'page_changed', 'html' => html, 'url' => url)
+    end
+
+    #
+    # Tells the viewer to save a screenshot of the current page to the given path.
+    # May not be available on all viewers.
+    #
+
+    def save(path)
+      send_data('method' => 'save', 'path' => path)
+    end
+
+
+    #
+    # Tells the viewer to dump the render tree to the given path.
+    # Only available in the Qt viewer.
+    #
+
+    def save_render_tree(path)
+      send_data('method' => 'save_render_tree', 'path' => path)
+    end
+
+    #
+    # Get the currently rendered page as a Base64-encoded PNG image.
+    # Only available in the Qt viewer.
+    #
+
+    def image_data
+      send_data('method' => 'image_data')
+      data = read_data
+      data['image'] || data['error']
+    end
+
+    #
+    # Close the connection.
+    #
+
+    def close
+      @socket.close rescue nil
+    end
+
+    private
+
+    def send_data(msg)
+      json = msg.to_json
+      data = "Content-Length: #{json.size}\n\n#{json}"
+      @socket.write data
+      @socket.flush
+
+      nil
+    end
+
+    def read_data
+      buf = ''
+      until buf =~ /\n\n\z/ || @socket.eof? || @socket.closed?
+        buf << @socket.read(1).to_s
+      end
+
+      return if buf.empty?
+
+      length = buf[/Content-Length: (\d+)/, 1].to_i
+      JSON.parse @socket.read(length)
+    end
+
+  end
+end

data/lib/celerity/watir_compatibility.rb

@@ -0,0 +1,70 @@
+module Celerity
+  class Browser
+    class << self
+
+      # Added for Watir compatibility - not in use by Celerity
+      attr_accessor :speed, :attach_timeout, :visible
+      # Added for Watir compatibility - not in use by Celerity
+      alias_method :start_window, :start
+      # Added for Watir compatibility - not in use by Celerity
+      def each; end
+    end
+
+    # Added for Watir compatibility - not in use by Celerity
+    attr_accessor :visible
+
+    # Added for Watir compatibility - not in use by Celerity
+    def bring_to_front; true; end
+    # Added for Watir compatibility - not in use by Celerity
+    def speed=(s); s end
+  end
+
+
+  module ClickableElement
+    alias_method :click_no_wait,    :click
+  end
+
+  module Container
+    alias_method :checkbox,         :check_box
+    alias_method :checkBox,         :check_box
+    alias_method :body,             :tbody
+    alias_method :bodies,           :tbodies
+  end
+
+  class Element
+    alias_method :exists,           :exists?
+    alias_method :innerText,        :text
+    alias_method :inner_text,       :text
+  end
+
+  class Image
+    alias_method :hasLoaded?,       :loaded?
+    alias_method :fileSize,         :file_size
+    alias_method :fileCreatedDate,  :file_created_date
+  end
+
+   class Link
+     alias_method :click_no_wait,   :click
+   end
+
+  class RadioCheckCommon
+    alias_method :isSet?,           :set?
+    alias_method :getState,         :set?
+  end
+
+  class SelectList
+    alias_method :getSelectedItems, :selected_options
+    alias_method :getAllContents,   :options
+    alias_method :clearSelection,   :clear
+    alias_method :includes?,        :include?
+  end
+
+  class TextField
+    alias_method :dragContentsTo,   :drag_contents_to
+    alias_method :getContents,      :value
+
+    def requires_typing; end
+  end
+end
+
+Celerity::IE = Celerity::Browser

data/lib/celerity/xpath_support.rb

@@ -0,0 +1,50 @@
+module Celerity
+
+  #
+  # Module to search by xpath
+  #
+
+  module XpathSupport
+
+    #
+    # Get the first element found matching the given XPath.
+    #
+    # @param [String] xpath
+    # @return [Celerity::Element] An element subclass (or Element if none is found)
+    #
+
+    def element_by_xpath(xpath)
+      assert_exists
+      obj = @page.getFirstByXPath(xpath)
+      element_from_dom_node(obj, ":xpath and #{xpath.inspect}")
+    end
+
+    #
+    # Get all the elements matching the given XPath.
+    #
+    # @param [String] xpath
+    # @return [Array<Celerity::Element>] array of elements
+    #
+
+    def elements_by_xpath(xpath)
+      assert_exists
+      objects = @page.getByXPath(xpath)
+      # should use an ElementCollection here?
+      objects.map { |o| element_from_dom_node(o) }
+    end
+
+    #
+    # Convert the given HtmlUnit DomNode to a Celerity object
+    #
+
+    def element_from_dom_node(obj, identifier_string = nil)
+      element_class = Util.htmlunit2celerity(obj.class) || Element
+      element = element_class.new(self, :object, obj)
+
+      element.identifier_string = identifier_string
+      element.extend(ClickableElement) unless element.is_a?(ClickableElement)
+
+      element
+    end
+  end
+end

data/spec/browser_authentication_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path("../watirspec/spec_helper", __FILE__)
+
+describe "Browser" do
+
+  describe "#credentials=" do
+    it "sets the basic authentication credentials" do
+      browser.goto(WatirSpec.host + "/authentication")
+
+      browser.text.should_not include("ok")
+      browser.credentials = "foo:bar"
+
+      browser.goto(WatirSpec.host + "/authentication")
+      browser.text.should include("ok")
+    end
+  end
+end

data/spec/browser_spec.rb

@@ -0,0 +1,439 @@
+# encoding: utf-8
+
+require File.expand_path("../watirspec/spec_helper", __FILE__)
+
+describe "Browser" do
+  describe "#new" do
+    it "raises TypeError if argument is not a Hash" do
+      lambda { Browser.new(:foo) }.should raise_error(TypeError)
+    end
+
+    it "raises ArgumentError if given bad arguments for :render key" do
+      lambda { Browser.new(:render => :foo) }.should raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError if given bad arguments for :browser key" do
+      lambda { Browser.new(:browser => 'foo') }.should raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError if given an unknown option" do
+      lambda { Browser.new(:foo => 1) }.should raise_error(ArgumentError)
+    end
+
+    it "should hold the init options" do
+      browser.options.should == WatirSpec.implementation.browser_args.first
+    end
+
+    it "should use the specified proxy" do
+      # TODO: find a better way to test this with rack
+      require 'webrick/httpproxy'
+
+      received = false
+      blk      = lambda { received = true }
+      port     = WatirSpec::Server.find_free_port_above(2001)
+
+      s = WEBrick::HTTPProxyServer.new(:Port => port,
+                                       :ProxyContentHandler => blk)
+      Thread.new { s.start }
+
+      opts = WatirSpec.implementation.browser_args.first.merge(:proxy => "localhost:#{port}")
+
+      begin
+        b = Browser.new(opts)
+        b.goto(WatirSpec.host)
+      ensure
+        s.shutdown
+        b.close if b
+      end
+
+      received.should be_true
+    end
+
+    it "should use the specified user agent" do
+      opts = WatirSpec.implementation.browser_args.first.merge(:user_agent => "Celerity")
+
+      b = Browser.new(opts)
+
+      begin
+        b.goto(WatirSpec.host + "/header_echo")
+        b.text.should include('"HTTP_USER_AGENT"=>"Celerity"')
+      ensure
+        b.close
+      end
+    end
+
+    it "does not try to find a viewer if created with :viewer => false" do
+      ViewerConnection.should_not_receive(:create)
+
+      Browser.new(:viewer => false).close
+    end
+
+    it "tries to find a viewer if created with :viewer => nil" do
+      ViewerConnection.should_receive(:create).with("127.0.0.1", 6429)
+
+      Browser.new(:viewer => nil).close
+    end
+
+    it "tries to find a viewer on the specified host/port with :viewer => String" do
+      ViewerConnection.should_receive(:create).with("localhost", 1234)
+
+      Browser.new(:viewer => "localhost:1234").close
+    end
+
+    it "should use the specified cache limit" do
+      opts = WatirSpec.implementation.browser_args.first.merge(:cache_limit => 100)
+      b = Browser.new(opts)
+
+      begin
+        b.cache_limit.should == 100
+      ensure
+        b.close
+      end
+    end
+
+    it "should use the Firefox 3 browser version when specified" do
+      Browser.new(:browser => :firefox).webclient.browser_version.nickname.should == "FF3"
+      Browser.new(:browser => :firefox3).webclient.browser_version.nickname.should == "FF3"
+    end
+
+    it "should use the Firefox 3.6 browser version when specified" do
+      Browser.new(:browser => :firefox_3_6).webclient.browser_version.nickname.should == "FF3.6"
+      Browser.new(:browser => :ff36).webclient.browser_version.nickname.should == "FF3.6"
+    end
+
+    it "should use the Internet Explorer 7 browser version when specified" do
+      Browser.new(:browser => :internet_explorer).webclient.browser_version.nickname.should == "IE7"
+      Browser.new(:browser => :internet_explorer7).webclient.browser_version.nickname.should == "IE7"
+      Browser.new(:browser => :internet_explorer_7).webclient.browser_version.nickname.should == "IE7"
+      Browser.new(:browser => :ie).webclient.browser_version.nickname.should == "IE7"
+    end
+
+    it "should use the Internet Explorer 8 browser version when specified" do
+      Browser.new(:browser => :internet_explorer_8).webclient.browser_version.nickname.should == "IE8"
+      Browser.new(:browser => :ie8).webclient.browser_version.nickname.should == "IE8"
+    end
+
+    it "should turn off CSS" do
+      b = Browser.new(:css => false)
+      b.css.should be_false
+    end
+
+  end
+
+  describe "#html" do
+    %w(shift_jis iso-2022-jp euc-jp).each do |charset|
+      it "returns decoded #{charset.upcase} when :charset specified" do
+        opts = WatirSpec.implementation.browser_args.first.merge(:charset => charset.upcase)
+        browser = Browser.new(opts)
+
+        begin
+          browser.goto(WatirSpec.files + "/#{charset}_text.html")
+          # Browser#text is automagically transcoded into the right charset, but Browser#html isn't.
+          browser.html.should =~ /本日は晴天なり。/
+        ensure
+          browser.close
+        end
+      end
+    end
+
+    it "does not fail for huge pages" do
+      browser.goto WatirSpec.host + "/big"
+      browser.html.should include("hello</body>")
+    end
+  end
+
+  describe "#text" do
+    it "does not fail for huge pages" do
+      browser.goto WatirSpec.host + "/big"
+      browser.text.should include("hello")
+    end
+  end
+
+  describe "#response_headers" do
+    it "returns the response headers (as a hash)" do
+      browser.goto(WatirSpec.host + "/non_control_elements.html")
+      browser.response_headers.should be_kind_of(Hash)
+      browser.response_headers['Date'].should be_kind_of(String)
+      browser.response_headers['Content-Type'].should be_kind_of(String)
+    end
+  end
+
+  describe "#content_type" do
+    it "returns the content type" do
+      browser.goto(WatirSpec.host + "/non_control_elements.html")
+      browser.content_type.should =~ /\w+\/\w+/
+    end
+  end
+
+  describe "#io" do
+    it "returns the io object of the content" do
+      browser.goto(WatirSpec.files + "/non_control_elements.html")
+      browser.io.should be_kind_of(IO)
+      browser.io.read.should == File.read("#{WatirSpec.html}/non_control_elements.html")
+    end
+  end
+
+  describe "#goto" do
+    it "raises UnexpectedPageException if the content type is not understood" do
+      lambda { browser.goto(WatirSpec.host + "/octet_stream") }.should raise_error(UnexpectedPageException)
+    end
+
+    it "takes a 2nd argument of headers" do
+      browser.goto(WatirSpec.host + "/header_echo", {'Accept-Language'=>'fr','Accept'=>'application/json'})
+      browser.text.should include('"HTTP_ACCEPT"=>"application/json"')
+      browser.text.should include('"HTTP_ACCEPT_LANGUAGE"=>"fr"')
+    end
+  end
+
+  describe "#cookies" do
+    it "returns set cookies as a Ruby hash" do
+      browser = WatirSpec.new_browser
+      begin
+        browser.cookies.should == {}
+
+        browser.goto(WatirSpec.host + "/set_cookie")
+
+        cookies = browser.cookies
+        cookies.size.should == 1
+        cookies[WatirSpec::Server.bind]['monster'].should == "/"
+      ensure
+        browser.close
+      end
+    end
+  end
+
+  describe "#clear_cookies" do
+    it "clears all cookies" do
+      b = WatirSpec.new_browser
+
+      begin
+        b.cookies.should be_empty
+
+        b.goto(WatirSpec.host + "/set_cookie")
+        b.cookies.size.should == 1
+        b.clear_cookies
+        b.cookies.should be_empty
+      ensure
+        b.close
+      end
+    end
+  end
+
+  describe "add_cookie" do
+    it "adds a cookie with the given domain, name and value" do
+      begin
+        browser.add_cookie("example.com", "foo", "bar")
+        cookies = browser.cookies
+        cookies.should be_instance_of(Hash)
+        cookies.should have_key('example.com')
+        cookies['example.com']['foo'].should == 'bar'
+      ensure
+        browser.clear_cookies
+      end
+    end
+
+    it "adds a cookie with the specified options" do
+      begin
+        browser.add_cookie("example.com", "foo", "bar", :path => "/foobar", :expires => Time.now + 100000)
+        cookies = browser.cookies
+        cookies.should be_instance_of(Hash)
+        cookies['example.com']['foo'].should == 'bar'
+      ensure
+        browser.clear_cookies
+      end
+    end
+  end
+
+  describe "remove_cookie" do
+    it "removes the cookie for the given domain and name" do
+      b = WatirSpec.new_browser
+      begin
+        b.goto(WatirSpec.host + "/set_cookie")
+
+        b.remove_cookie(WatirSpec::Server.bind, "monster")
+        b.cookies.should be_empty
+      ensure
+        b.close
+      end
+    end
+
+    it "raises an error if no such cookie exists" do
+      lambda { browser.remove_cookie("bogus.com", "bar") }.should raise_error(CookieNotFoundError)
+    end
+  end
+
+  describe "#wait" do
+    it "should wait for javascript timers to finish" do
+      alerts = 0
+      browser.add_listener(:alert) { alerts += 1 }
+      browser.goto(WatirSpec.files + "/timeout.html")
+      browser.div(:id, 'alert').click
+      browser.wait.should be_true
+      alerts.should == 1
+    end
+
+    it "should pass the correct args to webclient" do
+      browser.webclient.should_receive(:waitForBackgroundJavaScript).with(10000)
+      browser.wait
+
+      browser.webclient.should_receive(:waitForBackgroundJavaScript).with(3000)
+      browser.wait(3)
+    end
+
+  end
+
+  describe "#wait_while" do
+    it "waits until the specified condition becomes false" do
+      browser.goto(WatirSpec.files + "/timeout.html")
+      browser.div(:id, "change").click
+      browser.wait_while { browser.contains_text("Trigger change") }
+      browser.wait_until {
+        browser.div(:id, "change").text == "all done"
+      }
+    end
+
+    it "returns the value returned from the block" do
+      browser.wait_while { false }.should == false
+    end
+  end
+
+  describe "#wait_until" do
+    it "waits until the condition becomes true" do
+      browser.goto(WatirSpec.files + "/timeout.html")
+      browser.div(:id, "change").click
+      browser.wait_until { browser.contains_text("all done") }
+    end
+
+    it "returns the value returned from the block" do
+      browser.wait_until { true }.should == true
+    end
+  end
+
+  describe "#element_by_xpath" do
+    it "returns usable elements even though they're not supported" do
+      browser.goto(WatirSpec.files + "/forms_with_input_elements.html")
+
+      el = browser.element_by_xpath("//link")
+      el.should be_instance_of(Celerity::Element)
+      el.should be_kind_of(Celerity::ClickableElement)
+      el.rel.should == "stylesheet"
+    end
+
+    it "includes the xpath in an exception message" do
+      browser.goto(WatirSpec.files + "/forms_with_input_elements.html")
+
+      the_xpath = "//div[contains(@class, 'this does not exist')]"
+      el = browser.element_by_xpath(the_xpath)
+
+      lambda { el.visible? }.should raise_error(
+        Celerity::Exception::UnknownObjectException, Regexp.new(Regexp.escape(the_xpath)))
+    end
+  end
+
+  describe "#focused_element" do
+    it "returns the element that currently has the focus" do
+      b = WatirSpec.new_browser
+      b.goto(WatirSpec.files + "/forms_with_input_elements.html")
+      b.focused_element.id.should == "new_user_first_name"
+
+      b.close
+    end
+  end
+
+  describe "#status_code" do
+    it "returns the status code of the last request" do
+      browser.goto(WatirSpec.files + "/forms_with_input_elements.html")
+      browser.status_code.should == 200
+
+      browser.goto(WatirSpec.host + "/doesnt_exist")
+      browser.status_code.should == 404
+    end
+  end
+
+  describe "#status_code_exceptions" do
+    it "raises status code exceptions if set to true" do
+      browser.status_code_exceptions = true
+
+      begin
+        lambda {
+          browser.goto(WatirSpec.host + "/doesnt_exist")
+        }.should raise_error(NavigationException)
+      ensure
+        browser.status_code_exceptions = false
+      end
+    end
+  end
+
+  describe "#javascript_exceptions" do
+    it "raises javascript exceptions if set to true" do
+      browser.goto(WatirSpec.files + "/forms_with_input_elements.html")
+      browser.javascript_exceptions = true
+      begin
+        lambda { browser.execute_script("no_such_function()") }.should raise_error
+      ensure
+        browser.javascript_exceptions = false
+      end
+    end
+  end
+
+  describe "#add_listener" do
+    it "should click OK for confirm() calls" do
+      browser.goto(WatirSpec.files + "/forms_with_input_elements.html")
+      browser.add_listener(:confirm) {  }
+      browser.execute_script("confirm()").should == true
+    end
+  end
+
+  describe "#remove_listener" do
+    it "should remove the given listener Proc" do
+      browser.goto(WatirSpec.files + "/forms_with_input_elements.html")
+
+      called   = false
+      listener = lambda { called = true }
+
+      browser.add_listener(:alert, &listener)
+      browser.execute_script("alert('foo')")
+      called.should be_true
+
+      called = false
+      browser.remove_listener(:alert, listener)
+      browser.execute_script("alert('foo')")
+      called.should be_false
+    end
+  end
+
+  describe "#add_checker" do
+
+    # watir only supports a lambda instance as argument, celerity supports both
+    it "runs the given block on each page load" do
+      output = ''
+
+      browser.add_checker { |browser| output << browser.text }
+      browser.goto(WatirSpec.files + "/non_control_elements.html")
+
+      output.should include('Dubito, ergo cogito, ergo sum')
+    end
+  end
+
+
+  describe "#confirm" do
+    it "clicks 'OK' for a confirm() call" do
+      browser.goto(WatirSpec.files + "/forms_with_input_elements.html")
+
+      browser.confirm(true) do
+        browser.execute_script('confirm()').should be_true
+      end
+    end
+
+    it "clicks 'cancel' for a confirm() call" do
+      browser.goto(WatirSpec.files + "/forms_with_input_elements.html")
+
+      browser.confirm(false) do
+        browser.execute_script('confirm()').should be_false
+      end
+    end
+  end
+
+
+
+end