drnic-celerity 0.0.6.17

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

data/spec/clickable_element_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/watirspec/spec_helper'
+
+describe "ClickableElement" do
+
+  before :each do
+    browser.goto(WatirSpec.files + "/non_control_elements.html")
+  end
+
+  describe "#click_and_attach" do
+    it 'opens a page in a new browser with the same options' do
+      b = browser.link(:name, /bad_attribute/).click_and_attach
+      b.text.include?("User administration").should be_true # to make sure it is open.
+      b.options.should == browser.options
+      b.cookies.should == browser.cookies
+    end
+
+    it "opens the page in a new browser with the same cookies" do
+      browser.add_cookie("localhost", "foo", "bar")
+      old_cookies = browser.cookies
+      old_cookies.should_not be_empty
+
+      browser.goto(WatirSpec.files + "/non_control_elements.html")
+      b = browser.link(:name, /bad_attribute/).click_and_attach
+
+      b.should_not == browser
+      b.cookies.should == old_cookies
+    end
+  end
+
+  describe "#download" do
+    it 'returns a click-opened page as io' do
+      expected = File.read "#{WatirSpec.files}/forms_with_input_elements.html".sub("file://", '')
+
+      browser.link(:name, /bad_attribute/).download.read.should == expected
+      browser.link(:name, /bad_attribute/).should exist
+    end
+  end
+
+end

data/spec/default_viewer_spec.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/watirspec/spec_helper'
+
+describe "DefaultViewer" do
+
+  before :all do
+    browser.goto(WatirSpec.files + "/definition_lists.html")
+  end
+
+  describe ".save" do
+    it "saves the default image to the given path" do
+      fail("don't run specs with CelerityViewer") if browser.viewer != Celerity::DefaultViewer
+      fname   = File.expand_path "default_viewer_test.png"
+      default = "#{File.dirname(__FILE__)}/../lib/celerity/resources/no_viewer.png"
+
+      browser.viewer.save(fname)
+      File.exist?(fname).should be_true
+      File.read(fname).should == File.read(default)
+
+      File.delete(fname)
+    end
+  end
+end
+

data/spec/element_spec.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Element" do
+
+  before :each do
+    browser.goto(WatirSpec.files + "/forms_with_input_elements.html")
+  end
+
+  describe "#identifier_string" do
+    it "doesn't make the next locate find the wrong element" do
+      elem = browser.div(:id, 'hidden_parent')
+      elem.should exist
+      def elem.public_identifier_string; identifier_string end # method is private
+      elem.public_identifier_string
+      elem.id.should == 'hidden_parent'
+    end
+  end
+
+  describe "#method_missing" do
+    it "magically returns the requested attribute if the attribute is defined in the attribute list" do
+      browser.form(:index, 1).action.should == 'post_to_me'
+    end
+
+    it "raises NoMethodError if the requested method isn't among the attributes" do
+      lambda { browser.button(:index, 1).no_such_attribute_or_method }.should raise_error(NoMethodError)
+    end
+  end
+
+  describe "#xpath" do
+    it "gets the canonical xpath of this element" do
+      browser.text_field(:id, "new_user_email").xpath.should == '/html/body/form[1]/fieldset[1]/input[3]'
+    end
+  end
+
+  describe "#javascript_object" do
+    it "should return the JavaScript object representing the receiver" do
+      obj = browser.div(:id, "onfocus_test").javascript_object
+      obj.should be_kind_of(com.gargoylesoftware.htmlunit.javascript.host.html.HTMLElement)
+      obj.should be_instance_of(com.gargoylesoftware.htmlunit.javascript.host.html.HTMLDivElement)
+      obj.client_width.should be_kind_of(Integer)
+    end
+  end
+
+  describe "#locate" do
+    it "raises ArgumentError when used with :object and the object given isn't an HtmlElement subclass" do
+      lambda { Link.new(browser, :object, "foo").locate }.should raise_error(ArgumentError)
+    end
+  end
+
+end