celerity 0.0.6 → 0.0.7

data/lib/celerity/ignoring_web_connection.rb

@@ -0,0 +1,15 @@
+module Celerity
+  class IgnoringWebConnection < HtmlUnit::Util::FalsifyingWebConnection
+
+    def initialize(web_client, pattern)
+      super(web_client)
+      @pattern = pattern
+    end
+
+    def getResponse(request_settings)
+      return super unless request_settings.getUrl.toString =~ @pattern
+      createWebResponse(request_settings, "", "text/html")
+    end
+
+  end
+end

data/lib/celerity/input_element.rb

@@ -9,7 +9,7 @@ module Celerity
 
     def readonly?
       assert_exists
-      @object.isAttributeDefined('readonly')
+      @object.hasAttribute 'readonly'
     end
 
     private

data/lib/celerity/listener.rb

@@ -3,7 +3,7 @@ module Celerity
   #
   # This class is used to wrap some of the listeners available from HtmlUnit's WebClient.
   #
-  
+
   class Listener
     include com.gargoylesoftware.htmlunit.AlertHandler
     include com.gargoylesoftware.htmlunit.ConfirmHandler
@@ -18,12 +18,12 @@ module Celerity
       @webclient = webclient
       @procs = Hash.new { |h, k| h[k] = [] }
     end
-    
+
     #
     # Add a listener block for one of the available types.
     # @see Celerity::Browser#add_listener
     #
-    
+
     def add_listener(type, &block)
       case type
       when :status
@@ -63,51 +63,57 @@ module Celerity
         raise TypeError, "must give proc or index"
       end
     end
-    
+
     #
     # interface StatusHandler
     #
-    
+
     def statusMessageChanged(page, message)
       @procs[:status].each { |h| h.call(page, message) }
     end
-    
+
     #
     # interface AlertHandler
     #
-    
+
     def handleAlert(page, message)
       @procs[:alert].each { |h| h.call(page, message) }
     end
-    
+
     #
     # interface ConfirmHandler
     #
-    
+    # The returned value is determined by the last registered :confirm listener proc.
+    # If it is nil, return true, otherwise return that value as a boolean.
+    #
+    # @see Browser#confirm
+    #
+
     def handleConfirm(page, message)
-      @procs[:confirm].each { |h| h.call(page, message) }
+      val = @procs[:confirm].map { |h| h.call(page, message) }.last
+      val.nil? || !!val
     end
 
     #
     # interface AttachmentHandler
     #
-    
+
     def handleAttachment(page)
       @procs[:attachment].each { |h| h.call(page) }
     end
-    
+
     #
     # interface PromptHandler
     #
-    
+
     def handlePrompt(page, message)
       @procs[:prompt].each { |h| h.call(page, message) }
     end
-    
+
     #
     # interface WebWindowListener
     #
-    
+
     def webWindowClosed(web_window_event)
       @procs[:web_window_event].each { |h| h.call(web_window_event) }
     end
@@ -117,7 +123,7 @@ module Celerity
     #
     # interface HTMLParserListener
     #
-    
+
     def error(message, url, line, column, key)
       @procs[:html_parser].each { |h| h.call(message, url, line, column, key) }
     end
@@ -126,7 +132,7 @@ module Celerity
     #
     # interface IncorrectnessListener
     #
-    
+
     def notify(message, origin)
       @procs[:incorrectness].each { |h| h.call(message, origin) }
     end

data/lib/celerity/short_inspect.rb

@@ -0,0 +1,20 @@
+module Celerity
+  module ShortInspect
+
+    def short_inspect(opts)
+      if excluded_ivars = opts[:exclude]
+        ivars = (instance_variables - excluded_ivars)
+      elsif included_ivars = opts[:include]
+        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
+
+
+
+  end
+end

data/lib/celerity/util.rb

@@ -28,7 +28,6 @@ module Celerity
       HtmlUnit::Html::HtmlHiddenInput           => Celerity::Hidden,
       HtmlUnit::Html::HtmlImage                 => Celerity::Image,
       HtmlUnit::Html::HtmlLabel                 => Celerity::Label,
-      HtmlUnit::Html::HtmlLink                  => Celerity::Link,
       HtmlUnit::Html::HtmlListItem              => Celerity::Li,
       HtmlUnit::Html::HtmlMap                   => Celerity::Map,
       HtmlUnit::Html::HtmlOption                => Celerity::Option,
@@ -58,7 +57,7 @@ module Celerity
     # 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",
@@ -84,5 +83,9 @@ module Celerity
              strip
     end
 
+    def logger_for(package_string)
+      java.util.logging.Logger.getLogger(package_string)
+    end
+
   end
 end

data/lib/celerity/version.rb

@@ -1,10 +1,3 @@
-module Celerity #:nodoc:
-  module VERSION #:nodoc:
-    MAJOR = 0
-    MINOR = 0
-    TINY  = 6
-    PATCH = nil # Set to nil for official release
-    
-    STRING = [MAJOR, MINOR, TINY, PATCH].compact.join('.')
-  end
-end
+module Celerity
+  VERSION = "0.0.7"
+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

@@ -1,7 +1,7 @@
 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
@@ -25,8 +25,6 @@ module Celerity
     def bring_to_front; true; end
     # Added for Watir compatibility - not in use by Celerity
     def speed=(s); s end
-    # Added for Watir compatibility - not in use by Celerity
-    def status; '' end
   end
 
 
@@ -70,7 +68,6 @@ module Celerity
     alias_method :getAllContents,   :options
     alias_method :clearSelection,   :clear
     alias_method :clear_selection,  :clear
-    alias_method :select_value,     :select
     alias_method :includes?,        :include?
   end
 
@@ -78,7 +75,7 @@ module Celerity
     alias_method :dragContentsTo,   :drag_contents_to
     alias_method :getContents,      :value
     alias_method :get_contents,     :value
-    
+
     def requires_typing; end
   end
 end

data/lib/celerity/xpath_support.rb

@@ -0,0 +1,48 @@
+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)
+    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) }.compact
+    end
+
+    #
+    # Convert the given HtmlUnit DomNode to a Celerity object
+    #
+
+    def element_from_dom_node(obj)
+      element_class = Util.htmlunit2celerity(obj.class) || Element
+      element_class.new(self, :object, obj)
+    end
+
+
+  end
+
+end

data/spec/browser_authentication_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/watirspec/spec_helper'
+
+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,300 @@
+require File.dirname(__FILE__) + '/watirspec/spec_helper'
+
+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.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 }
+      s = WEBrick::HTTPProxyServer.new(:Port => 2001, :ProxyContentHandler => blk)
+      Thread.new { s.start }
+
+      b = Browser.new(WatirSpec.browser_args.first.merge(:proxy => "localhost:2001"))
+      b.goto(WatirSpec.host)
+      s.shutdown
+
+      received.should be_true
+    end
+
+    it "should use the specified user agent" do
+      b = Browser.new(WatirSpec.browser_args.first.merge(:user_agent => "Celerity"))
+      b.goto(WatirSpec.host + "/header_echo")
+      b.text.should include('"HTTP_USER_AGENT"=>"Celerity"')
+      b.close
+    end
+
+    it "does not try to find a viewer if created with :viewer => false" do
+      ViewerConnection.should_not_receive(:create)
+
+      b = Browser.new(:viewer => false)
+      b.close
+    end
+
+    it "tries to find a viewer if created with :viewer => nil" do
+      ViewerConnection.should_receive(:create).with("127.0.0.1", 6429)
+
+      b = Browser.new(:viewer => nil)
+      b.close
+    end
+
+    it "tries to find a viewer on the specified host/port with :viewer => String" do
+      ViewerConnection.should_receive(:create).with("localhost", 1234)
+
+      b = Browser.new(:viewer => "localhost:1234")
+      b.close
+    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
+        browser = Browser.new(WatirSpec.browser_args.first.merge(:charset => charset.upcase))
+        browser.goto(WatirSpec.files + "/#{charset}_text.html")
+        # Browser#text is automagically transcoded into the right charset, but Browser#html isn't.
+        browser.html.should =~ /本日は晴天なり。/
+        browser.close
+      end
+    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
+  end
+
+  describe "#cookies" do
+    it "returns set cookies as a Ruby hash" do
+      cookies = browser.cookies
+      cookies.should be_instance_of(Hash)
+      cookies.should be_empty
+
+      browser.goto(WatirSpec.host + "/set_cookie")
+
+      cookies = browser.cookies
+      cookies.size.should == 1
+      cookies[WatirSpec::Server.host]['monster'].should == "/"
+    end
+  end
+
+  describe "#clear_cookies" do
+    it "clears all cookies" do
+      b = WatirSpec.new_browser
+      b.cookies.should be_empty
+
+      b.goto(WatirSpec.host + "/set_cookie")
+      b.cookies.size.should == 1
+      b.clear_cookies
+      b.cookies.should be_empty
+
+      b.close
+    end
+  end
+
+  describe "add_cookie" do
+    it "adds a cookie with the given domain, name and value" do
+      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'
+
+      browser.clear_cookies
+    end
+
+    it "adds a cookie with the specified options" do
+      browser.add_cookie("example.com", "foo", "bar", :path => "/foobar", :max_age => 1000)
+      cookies = browser.cookies
+      cookies.should be_instance_of(Hash)
+      cookies['example.com']['foo'].should == 'bar'
+    end
+  end
+
+  describe "remove_cookie" do
+    it "removes the cookie for the given domain and name" do
+      b = WatirSpec.new_browser
+      b.goto(WatirSpec.host + "/set_cookie")
+
+      b.remove_cookie(WatirSpec::Server.host, "monster")
+      b.cookies.should be_empty
+
+      b.close
+    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
+  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.div(:id, "change").text.should == "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.rel.should == "stylesheet"
+    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
+      lambda do
+        browser.goto(WatirSpec.host + "/doesnt_exist")
+      end.should raise_error(NavigationException)
+    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
+      lambda do
+        browser.execute_script("no_such_function()")
+      end.should raise_error
+    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 "#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