bbc-capybara 1.1.2

data/lib/capybara/selenium/driver.rb

@@ -0,0 +1,169 @@
+require 'selenium-webdriver'
+
+class Capybara::Selenium::Driver < Capybara::Driver::Base
+  DEFAULT_OPTIONS = {
+    :resynchronize => false,
+    :resynchronization_timeout => 10,
+    :browser => :firefox
+  }
+  SPECIAL_OPTIONS = [:browser, :resynchronize, :resynchronization_timeout]
+
+  attr_reader :app, :rack_server, :options
+
+  def browser
+    unless @browser
+      @browser = Selenium::WebDriver.for(options[:browser], options.reject { |key,val| SPECIAL_OPTIONS.include?(key) })
+
+      main = Process.pid
+      at_exit do
+        # Store the exit status of the test run since it goes away after calling the at_exit proc...
+        @exit_status = $!.status if $!.is_a?(SystemExit)
+        quit if Process.pid == main
+        exit @exit_status if @exit_status # Force exit with stored status
+      end
+    end
+    @browser
+  end
+
+  def initialize(app, options={})
+    @app = app
+    @browser = nil
+    @exit_status = nil
+    @options = DEFAULT_OPTIONS.merge(options)
+    @rack_server = Capybara::Server.new(@app)
+    @rack_server.boot if Capybara.run_server
+  end
+
+  def visit(path)
+    browser.navigate.to(url(path))
+  end
+
+  def source
+    browser.page_source
+  end
+
+  def body
+    browser.page_source
+  end
+
+  def current_url
+    browser.current_url
+  end
+  
+  def set_orientation(orientation)
+    browser.rotation(orientation)
+  end
+
+  def find(selector)
+    browser.find_elements(:xpath, selector).map { |node| Capybara::Selenium::Node.new(self, node) }
+  end
+
+  def wait?; true; end
+
+  def resynchronize
+    if options[:resynchronize]
+      load_wait_for_ajax_support
+      yield
+      Capybara.timeout(options[:resynchronization_timeout], self, "failed to resynchronize, ajax request timed out") do
+        evaluate_script("!window.capybaraRequestsOutstanding")
+      end
+    else
+      yield
+    end
+  end
+
+  def execute_script(script)
+    browser.execute_script script
+  end
+
+  def evaluate_script(script)
+    browser.execute_script "return #{script}"
+  end
+
+  def reset!
+    # Use instance variable directly so we avoid starting the browser just to reset the session
+    if @browser
+      begin
+        @browser.manage.delete_all_cookies
+      rescue Selenium::WebDriver::Error::UnhandledError
+        # delete_all_cookies fails when we've previously gone
+        # to about:blank, so we rescue this error and do nothing
+        # instead.
+      end
+      @browser.navigate.to('about:blank')
+    end
+  end
+
+  def within_frame(frame_id)
+    old_window = browser.window_handle
+    browser.switch_to.frame(frame_id)
+    yield
+    browser.switch_to.window old_window
+  end
+
+  def find_window( selector )
+    original_handle = browser.window_handle
+    browser.window_handles.each do |handle|
+      browser.switch_to.window handle
+      if( selector == browser.execute_script("return window.name") ||
+          browser.title.include?(selector) ||
+          browser.current_url.include?(selector) ||
+          (selector == handle) )
+        browser.switch_to.window original_handle
+        return handle
+      end
+    end
+    raise Capybara::ElementNotFound, "Could not find a window identified by #{selector}"
+  end
+
+  def within_window(selector, &blk)
+    handle = find_window( selector )
+    browser.switch_to.window(handle, &blk)
+  end
+
+  def quit
+    @browser.quit
+  rescue Errno::ECONNREFUSED
+    # Browser must have already gone
+  end
+
+  def invalid_element_errors
+    [Selenium::WebDriver::Error::ObsoleteElementError, Selenium::WebDriver::Error::UnhandledError]
+  end
+
+private
+
+  def load_wait_for_ajax_support
+    browser.execute_script <<-JS
+      window.capybaraRequestsOutstanding = 0;
+      (function() { // Overriding XMLHttpRequest
+          var oldXHR = window.XMLHttpRequest;
+
+          function newXHR() {
+              var realXHR = new oldXHR();
+
+              window.capybaraRequestsOutstanding++;
+              realXHR.addEventListener("readystatechange", function() {
+                  if( realXHR.readyState == 4 ) {
+                    setTimeout( function() {
+                      window.capybaraRequestsOutstanding--;
+                      if(window.capybaraRequestsOutstanding < 0) {
+                        window.capybaraRequestsOutstanding = 0;
+                      }
+                    }, 500 );
+                  }
+              }, false);
+
+              return realXHR;
+          }
+
+          window.XMLHttpRequest = newXHR;
+      })();
+    JS
+  end
+
+  def url(path)
+    rack_server.url(path)
+  end
+
+end

data/lib/capybara/selenium/node.rb

@@ -0,0 +1,91 @@
+class Capybara::Selenium::Node < Capybara::Driver::Node
+  def text
+    native.text
+  end
+
+  def [](name)
+    native.attribute(name.to_s)
+  rescue Selenium::WebDriver::Error::WebDriverError
+    nil
+  end
+
+  def value
+    if tag_name == "select" and self[:multiple] and not self[:multiple] == "false"
+      native.find_elements(:xpath, ".//option").select { |n| n.selected? }.map { |n| n[:value] || n.text }
+    else
+      native[:value]
+    end
+  end
+
+  def set(value)
+    if tag_name == 'input' and type == 'radio'
+      click
+    elsif tag_name == 'input' and type == 'checkbox'
+      click if value ^ native.attribute('checked').to_s.eql?("true")
+    elsif tag_name == 'input' and type == 'file'
+      resynchronize do
+        native.send_keys(value.to_s)
+      end
+    elsif tag_name == 'textarea' or tag_name == 'input'
+      resynchronize do
+        native.clear
+        native.send_keys(value.to_s)
+      end
+    end
+  end
+
+  def select_option
+    resynchronize { native.click } unless selected?
+  end
+
+  def unselect_option
+    if select_node['multiple'] != 'multiple' and select_node['multiple'] != 'true'
+      raise Capybara::UnselectNotAllowed, "Cannot unselect option from single select box."
+    end
+    resynchronize { native.click } if selected?
+  end
+
+  def click
+    resynchronize { native.click }
+  end
+
+  def drag_to(element)
+    resynchronize { driver.browser.action.drag_and_drop(native, element.native).perform }
+  end
+
+  def tag_name
+    native.tag_name.downcase
+  end
+
+  def visible?
+    displayed = native.displayed?
+    displayed and displayed != "false"
+  end
+
+  def selected?
+    selected = native.selected?
+    selected and selected != "false"
+  end
+
+  alias :checked? :selected?
+
+  def find(locator)
+    native.find_elements(:xpath, locator).map { |n| self.class.new(driver, n) }
+  end
+
+private
+
+  def resynchronize
+    driver.resynchronize { yield }
+  end
+
+  # a reference to the select node if this is an option node
+  def select_node
+    find('./ancestor::select').first
+  end
+
+  def type
+    self[:type]
+  end
+
+end

data/lib/capybara/server.rb

@@ -0,0 +1,87 @@
+require 'uri'
+require 'net/http'
+require 'rack'
+require 'capybara/util/timeout'
+
+module Capybara
+  class Server
+    class Identify
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if env["PATH_INFO"] == "/__identify__"
+          [200, {}, [@app.object_id.to_s]]
+        else
+          @app.call(env)
+        end
+      end
+    end
+
+    class << self
+      def ports
+        @ports ||= {}
+      end
+    end
+
+    attr_reader :app, :port
+
+    def initialize(app)
+      @app = app
+    end
+
+    def host
+      Capybara.server_host || "127.0.0.1"
+    end
+
+    def url(path)
+      if path =~ /^http/
+        path
+      else
+        (Capybara.app_host || "http://#{host}:#{port}") + path.to_s
+      end
+    end
+
+    def responsive?
+      res = Net::HTTP.start(host, @port) { |http| http.get('/__identify__') }
+
+      if res.is_a?(Net::HTTPSuccess) or res.is_a?(Net::HTTPRedirection)
+        return res.body == @app.object_id.to_s
+      end
+    rescue Errno::ECONNREFUSED, Errno::EBADF
+      return false
+    end
+
+    def boot
+      if @app
+        @port = Capybara::Server.ports[@app.object_id]
+
+        if not @port or not responsive?
+          @port = Capybara.server_port || find_available_port
+          Capybara::Server.ports[@app.object_id] = @port
+
+          Thread.new do
+            Capybara.server.call(Identify.new(@app), @port)
+          end
+
+          Capybara.timeout(60) { responsive? }
+        end
+      end
+    rescue TimeoutError
+      raise "Rack application timed out during boot"
+    else
+      self
+    end
+
+  private
+
+    def find_available_port
+      server = TCPServer.new('127.0.0.1', 0)
+      server.addr[1]
+    ensure
+      server.close if server
+    end
+
+  end
+end

data/lib/capybara/session.rb

@@ -0,0 +1,322 @@
+require 'capybara/util/timeout'
+
+module Capybara
+
+  ##
+  #
+  # The Session class represents a single user's interaction with the system. The Session can use
+  # any of the underlying drivers. A session can be initialized manually like this:
+  #
+  #     session = Capybara::Session.new(:culerity, MyRackApp)
+  #
+  # The application given as the second argument is optional. When running Capybara against an external
+  # page, you might want to leave it out:
+  #
+  #     session = Capybara::Session.new(:culerity)
+  #     session.visit('http://www.google.com')
+  #
+  # Session provides a number of methods for controlling the navigation of the page, such as +visit+,
+  # +current_path, and so on. It also delegate a number of methods to a Capybara::Document, representing
+  # the current HTML document. This allows interaction:
+  #
+  #     session.fill_in('q', :with => 'Capybara')
+  #     session.click_button('Search')
+  #     session.should have_content('Capybara')
+  #
+  # When using capybara/dsl, the Session is initialized automatically for you.
+  #
+  class Session
+    NODE_METHODS = [
+      :all, :first, :attach_file, :text, :check, :choose,
+      :click_link_or_button, :click_button, :click_link, :field_labeled,
+      :fill_in, :find, :find_button, :find_by_id, :find_field, :find_link,
+      :has_content?, :has_text?, :has_css?, :has_no_content?, :has_no_text?,
+      :has_no_css?, :has_no_xpath?,
+      :has_xpath?, :select, :uncheck, :has_link?, :has_no_link?, :has_button?,
+      :has_no_button?, :has_field?, :has_no_field?, :has_checked_field?,
+      :has_unchecked_field?, :has_no_table?, :has_table?, :unselect,
+      :has_select?, :has_no_select?, :has_selector?, :has_no_selector?,
+      :click_on, :has_no_checked_field?, :has_no_unchecked_field?
+    ]
+    SESSION_METHODS = [
+      :body, :html, :current_url, :current_host, :evaluate_script, :source,
+      :visit, :wait_until, :within, :within_fieldset, :within_table,
+      :within_frame, :within_window, :current_path, :save_page,
+      :save_and_open_page, :reset_session!
+    ]
+    DSL_METHODS = NODE_METHODS + SESSION_METHODS
+
+    attr_reader :mode, :app
+
+    def initialize(mode, app=nil)
+      @mode = mode
+      @app = app
+    end
+
+    def driver
+      @driver ||= begin
+        unless Capybara.drivers.has_key?(mode)
+          other_drivers = Capybara.drivers.keys.map { |key| key.inspect }
+          raise Capybara::DriverNotFoundError, "no driver called #{mode.inspect} was found, available drivers: #{other_drivers.join(', ')}"
+        end
+        Capybara.drivers[mode].call(app)
+      end
+    end
+
+    ##
+    #
+    # Reset the session, removing all cookies.
+    #
+    def reset!
+      driver.reset!
+    end
+    alias_method :cleanup!, :reset!
+    alias_method :reset_session!, :reset!
+
+    ##
+    #
+    # Returns a hash of response headers. Not supported by all drivers (e.g. Selenium)
+    #
+    # @return [Hash{String => String}] A hash of response headers.
+    #
+    def response_headers
+      driver.response_headers
+    end
+
+    ##
+    #
+    # Returns the current HTTP status code as an Integer. Not supported by all drivers (e.g. Selenium)
+    #
+    # @return [Integer] Current HTTP status code
+    #
+    def status_code
+      driver.status_code
+    end
+
+    ##
+    #
+    # @return [String] A snapshot of the HTML of the current document, as it looks right now (potentially modified by JavaScript).
+    #
+    def html
+      driver.body
+    end
+
+    ##
+    #
+    # @return [String] HTML source of the document, before being modified by JavaScript.
+    #
+    def source
+      driver.source
+    end
+    alias_method :body, :source
+
+    ##
+    #
+    # @return [String] Path of the current page, without any domain information
+    #
+    def current_path
+      path = URI.parse(current_url).path
+      path if path and not path.empty?
+    end
+
+    ##
+    #
+    # @return [String] Host of the current page
+    #
+    def current_host
+      uri = URI.parse(current_url)
+      "#{uri.scheme}://#{uri.host}" if uri.host
+    end
+
+    ##
+    #
+    # @return [String] Fully qualified URL of the current page
+    #
+    def current_url
+      driver.current_url
+    end
+
+    ##
+    #
+    # Navigate to the given URL. The URL can either be a relative URL or an absolute URL
+    # The behaviour of either depends on the driver.
+    #
+    #     session.visit('/foo')
+    #     session.visit('http://google.com')
+    #
+    # For drivers which can run against an external application, such as culerity and selenium
+    # giving an absolute URL will navigate to that page. This allows testing applications
+    # running on remote servers. For these drivers, setting Capybara.app_host will make the
+    # remote server the default. For example:
+    #
+    #     Capybara.app_host = 'http://google.com'
+    #     session.visit('/') # visits the google homepage
+    #
+    # @param [String] url     The URL to navigate to
+    #
+    def visit(url)
+      driver.visit(url)
+    end
+
+    ##
+    #
+    # Execute the given block for a particular scope on the page. Within will find the first
+    # element matching the given selector and execute the block scoped to that element:
+    #
+    #     within(:xpath, '//div[@id="delivery-address"]') do
+    #       fill_in('Street', :with => '12 Main Street')
+    #     end
+    #
+    # It is possible to omit the first parameter, in that case, the selector is assumed to be
+    # of the type set in Capybara.default_selector.
+    #
+    #     within('div#delivery-address') do
+    #       fill_in('Street', :with => '12 Main Street')
+    #     end
+    #
+    # @overload within(*find_args)
+    #   @param (see Capybara::Node::Finders#all)
+    #
+    # @overload within(a_node)
+    #   @param [Capybara::Node::Base] a_node   The node in whose scope the block should be evaluated
+    #
+    # @raise  [Capybara::ElementNotFound]   If the scope can't be found before time expires
+    #
+    def within(*args)
+      new_scope = if args.size == 1 && Capybara::Node::Base === args.first
+                    args.first
+                  else
+                    find(*args)
+                  end
+      begin
+        scopes.push(new_scope)
+        yield
+      ensure
+        scopes.pop
+      end
+    end
+
+    ##
+    #
+    # Execute the given block within the a specific fieldset given the id or legend of that fieldset.
+    #
+    # @param [String] locator    Id or legend of the fieldset
+    #
+    def within_fieldset(locator)
+      within :fieldset, locator do
+        yield
+      end
+    end
+
+    ##
+    #
+    # Execute the given block within the a specific table given the id or caption of that table.
+    #
+    # @param [String] locator    Id or caption of the table
+    #
+    def within_table(locator)
+      within :table, locator do
+        yield
+      end
+    end
+
+    ##
+    #
+    # Execute the given block within the given iframe given the id of that iframe. Only works on
+    # some drivers (e.g. Selenium)
+    #
+    # @param [String] locator    Id of the frame
+    #
+    def within_frame(frame_id)
+      driver.within_frame(frame_id) do
+        yield
+      end
+    end
+
+    ##
+    #
+    # Execute the given block within the given window. Only works on
+    # some drivers (e.g. Selenium)
+    #
+    # @param [String] locator of the window
+    #
+    def within_window(handle, &blk)
+      driver.within_window(handle, &blk)
+    end
+
+    ##
+    #
+    # Retry executing the block until a truthy result is returned or the timeout time is exceeded
+    #
+    # @param [Integer] timeout   The amount of seconds to retry executing the given block
+    #
+    def wait_until(timeout = Capybara.default_wait_time)
+      Capybara.timeout(timeout,driver) { yield }
+    end
+
+    ##
+    #
+    # Execute the given script, not returning a result. This is useful for scripts that return
+    # complex objects, such as jQuery statements. +execute_script+ should be used over
+    # +evaluate_script+ whenever possible.
+    #
+    # @param [String] script   A string of JavaScript to execute
+    #
+    def execute_script(script)
+      driver.execute_script(script)
+    end
+
+    ##
+    #
+    # Evaluate the given JavaScript and return the result. Be careful when using this with
+    # scripts that return complex objects, such as jQuery statements. +execute_script+ might
+    # be a better alternative.
+    #
+    # @param  [String] script   A string of JavaScript to evaluate
+    # @return [Object]          The result of the evaluated JavaScript (may be driver specific)
+    #
+    def evaluate_script(script)
+      driver.evaluate_script(script)
+    end
+
+    ##
+    #
+    # Save a snapshot of the page and open it in a browser for inspection
+    #
+    def save_page
+      require 'capybara/util/save_and_open_page'
+      Capybara.save_page(body)
+    end
+
+    def save_and_open_page
+      require 'capybara/util/save_and_open_page'
+      Capybara.save_and_open_page(body)
+    end
+
+    def document
+      @document ||= Capybara::Node::Document.new(self, driver)
+    end
+
+    NODE_METHODS.each do |method|
+      class_eval <<-RUBY
+        def #{method}(*args, &block)
+          current_node.send(:#{method}, *args, &block)
+        end
+      RUBY
+    end
+
+    def inspect
+      %(#<Capybara::Session>)
+    end
+
+  private
+
+    def current_node
+      scopes.last
+    end
+
+    def scopes
+      @scopes ||= [document]
+    end
+  end
+end