rcarvalho-capybara 0.4.1.1

data/lib/capybara.rb

@@ -0,0 +1,231 @@
+require 'timeout'
+require 'nokogiri'
+require 'xpath'
+module Capybara
+  class CapybaraError < StandardError; end
+  class DriverNotFoundError < CapybaraError; end
+  class ElementNotFound < CapybaraError; end
+  class UnselectNotAllowed < CapybaraError; end
+  class NotSupportedByDriverError < CapybaraError; end
+  class TimeoutError < CapybaraError; end
+  class LocateHiddenElementError < CapybaraError; end
+  class InfiniteRedirectError < TimeoutError; end
+
+  class << self
+    attr_accessor :asset_root, :app_host, :run_server, :default_host
+    attr_accessor :server_port, :server_boot_timeout
+    attr_accessor :default_selector, :default_wait_time, :ignore_hidden_elements
+    attr_accessor :save_and_open_page_path
+
+    ##
+    #
+    # Configure Capybara to suit your needs.
+    #
+    #     Capybara.configure do |config|
+    #       config.run_server = false
+    #       config.app_host   = 'http://www.google.com'
+    #     end
+    #
+    # === Configurable options
+    #
+    # [asset_root = String]               Where static assets are located, used by save_and_open_page
+    # [app_host = String]                 The default host to use when giving a relative URL to visit
+    # [run_server = Boolean]              Whether to start a Rack server for the given Rack app (Default: true)
+    # [default_selector = :css/:xpath]    Methods which take a selector use the given type by default (Default: CSS)
+    # [default_wait_time = Integer]       The number of seconds to wait for asynchronous processes to finish (Default: 2)
+    # [ignore_hidden_elements = Boolean]  Whether to ignore hidden elements on the page (Default: false)
+    #
+    # === DSL Options
+    #
+    # when using capybara/dsl, the following options are also available:
+    #
+    # [default_driver = Symbol]           The name of the driver to use by default. (Default: :rack_test)
+    # [javascript_driver = Symbol]        The name of a driver to use for JavaScript enabled tests. (Default: :selenium)
+    #
+    def configure
+      yield self
+    end
+
+    ##
+    #
+    # Register a new driver for Capybara.
+    #
+    #     Capybara.register_driver :rack_test do |app|
+    #       Capybara::Driver::RackTest.new(app)
+    #     end
+    #
+    # @param [Symbol] name                    The name of the new driver
+    # @yield [app]                            This block takes a rack app and returns a Capybara driver
+    # @yieldparam [<Rack>] app                The rack application that this driver runs agains. May be nil.
+    # @yieldreturn [Capybara::Driver::Base]   A Capybara driver instance
+    #
+    def register_driver(name, &block)
+      drivers[name] = block
+    end
+
+    ##
+    #
+    # Add a new selector to Capybara. Selectors can be used by various methods in Capybara
+    # to find certain elements on the page in a more convenient way. For example adding a
+    # selector to find certain table rows might look like this:
+    #
+    #     Capybara.add_selector(:row) do
+    #       xpath { |num| ".//tbody/tr[#{num}]" }
+    #     end
+    #
+    # This makes it possible to use this selector in a variety of ways:
+    #
+    #     find(:row, 3)
+    #     page.find('table#myTable').find(:row, 3).text
+    #     page.find('table#myTable').has_selector?(:row, 3)
+    #     within(:row, 3) { page.should have_content('$100.000') }
+    #
+    # It might be convenient to specify that the selector is automatically chosen for certain
+    # values. This way you don't have to explicitely specify that you are looking for a row, or
+    # an id. Let's say we want Capybara to treat any Symbols sent into methods like find to be
+    # treated as though they were element ids. We could achieve this like so:
+    #
+    #     Capybara.add_selector(:id) do
+    #       xpath { |id| XPath.descendant[XPath.attr(:id) == id.to_s] }
+    #       match { |value| value.is_a?(Symbol) }
+    #     end
+    #
+    # Now we can retrieve elements by id like this:
+    #
+    #     find(:post_123)
+    #
+    # Note that this particular selector already ships with Capybara.
+    #
+    # @param [Symbol] name    The name of the selector to add
+    # @yield                  A block executed in the context of the new {Capybara::Selector}
+    #
+    def add_selector(name, &block)
+      Capybara::Selector.add(name, &block)
+    end
+
+    def drivers
+      @drivers ||= {}
+    end
+
+    ##
+    #
+    # Register a proc that Capybara will call to run the Rack application.
+    #
+    #     Capybara.server do |app, port|
+    #       require 'rack/handler/mongrel'
+    #       Rack::Handler::Mongrel.run(app, :Port => port)
+    #     end
+    #
+    # By default, Capybara will try to run thin, falling back to webrick.
+    #
+    # @yield [app, port]                      This block recieves a rack app and port and should run a Rack handler
+    #
+    def server(&block)
+      if block_given?
+        @server = block
+      else
+        @server
+      end
+    end
+
+    ##
+    #
+    # Wraps the given string, which should contain an HTML document or fragment
+    # in a {Capybara::Node::Simple} which exposes all {Capybara::Node::Matchers} and
+    # {Capybara::Node::Finders}. This allows you to query any string containing
+    # HTML in the exact same way you would query the current document in a Capybara
+    # session. For example:
+    #
+    #     node = Capybara.string <<-HTML
+    #       <ul>
+    #         <li id="home">Home</li>
+    #         <li id="projects">Projects</li>
+    #       </ul>
+    #     HTML
+    #
+    #     node.find('#projects').text # => 'Projects'
+    #     node.has_selector?('li#home', :text => 'Home')
+    #     node.has_selector?(:projects)
+    #     node.find('ul').find('li').text # => 'Home'
+    #
+    # @param [String] html              An html fragment or document
+    # @return [Capybara::Node::Simple]   A node which has Capybara's finders and matchers
+    #
+    def string(html)
+      Capybara::Node::Simple.new(html)
+    end
+
+    ##
+    #
+    # Runs Capybara's default server for the given application and port
+    # under most circumstances you should not have to call this method
+    # manually.
+    #
+    # @param [Rack Application] app    The rack application to run
+    # @param [Fixnum] port              The port to run the application on
+    #
+    def run_default_server(app, port)
+      begin
+        require 'rack/handler/thin'
+        Thin::Logging.silent = true
+        Rack::Handler::Thin.run(app, :Port => port)
+      rescue LoadError
+        require 'rack/handler/webrick'
+        Rack::Handler::WEBrick.run(app, :Port => port, :AccessLog => [], :Logger => WEBrick::Log::new(nil, 0))
+      end
+    end
+
+    def deprecate(method, alternate_method)
+      warn "DEPRECATED: ##{method} is deprecated, please use ##{alternate_method} instead"
+    end
+  end
+
+  autoload :Server,     'capybara/server'
+  autoload :Session,    'capybara/session'
+  autoload :Selector,   'capybara/selector'
+  autoload :VERSION,    'capybara/version'
+
+  module Node
+    autoload :Base,       'capybara/node/base'
+    autoload :Simple,     'capybara/node/simple'
+    autoload :Element,    'capybara/node/element'
+    autoload :Document,   'capybara/node/document'
+    autoload :Finders,    'capybara/node/finders'
+    autoload :Matchers,   'capybara/node/matchers'
+    autoload :Actions,    'capybara/node/actions'
+  end
+
+  module Driver
+    autoload :Base,     'capybara/driver/base'
+    autoload :Node,     'capybara/driver/node'
+    autoload :RackTest, 'capybara/driver/rack_test_driver'
+    autoload :Celerity, 'capybara/driver/celerity_driver'
+    autoload :Culerity, 'capybara/driver/culerity_driver'
+    autoload :Selenium, 'capybara/driver/selenium_driver'
+  end
+end
+
+Capybara.configure do |config|
+  config.run_server = true
+  config.server {|app, port| Capybara.run_default_server(app, port)}
+  config.server_boot_timeout = 10
+  config.default_selector = :css
+  config.default_wait_time = 2
+  config.ignore_hidden_elements = false
+end
+
+Capybara.register_driver :rack_test do |app|
+  Capybara::Driver::RackTest.new(app)
+end
+
+Capybara.register_driver :celerity do |app|
+  Capybara::Driver::Celerity.new(app)
+end
+
+Capybara.register_driver :culerity do |app|
+  Capybara::Driver::Culerity.new(app)
+end
+
+Capybara.register_driver :selenium do |app|
+  Capybara::Driver::Selenium.new(app)
+end

data/lib/capybara/cucumber.rb

@@ -0,0 +1,32 @@
+require 'capybara'
+require 'capybara/dsl'
+
+World(Capybara)
+
+After do
+  Capybara.reset_sessions!
+end
+
+Before('@javascript') do
+  Capybara.current_driver = Capybara.javascript_driver
+end
+
+Before('@selenium') do
+  Capybara.current_driver = :selenium
+end
+
+Before('@celerity') do
+  Capybara.current_driver = :celerity
+end
+
+Before('@culerity') do
+  Capybara.current_driver = :culerity
+end
+
+Before('@rack_test') do
+  Capybara.current_driver = :rack_test
+end
+
+After do
+  Capybara.use_default_driver
+end

data/lib/capybara/driver/base.rb

@@ -0,0 +1,60 @@
+class Capybara::Driver::Base
+  def current_url
+    raise NotImplementedError
+  end
+
+  def visit(path)
+    raise NotImplementedError
+  end
+
+  def find(query)
+    raise NotImplementedError
+  end
+
+  def source
+    raise NotImplementedError
+  end
+
+  def body
+    raise NotImplementedError
+  end
+
+  def execute_script(script)
+    raise Capybara::NotSupportedByDriverError
+  end
+
+  def evaluate_script(script)
+    raise Capybara::NotSupportedByDriverError
+  end
+
+  def response_headers
+    raise Capybara::NotSupportedByDriverError
+  end
+
+  def status_code
+    raise Capybara::NotSupportedByDriverError
+  end
+
+  def within_frame(frame_id)
+    raise Capybara::NotSupportedByDriverError
+  end
+
+  def within_window(handle)
+    raise Capybara::NotSupportedByDriverError
+  end
+
+  def wait?
+    false
+  end
+
+  def wait_until(*args)
+  end
+
+  def reset!
+  end
+
+  def has_shortcircuit_timeout?
+    false
+  end
+
+end

data/lib/capybara/driver/celerity_driver.rb

@@ -0,0 +1,164 @@
+class Capybara::Driver::Celerity < Capybara::Driver::Base
+  class Node < Capybara::Driver::Node
+    def text
+      native.text
+    end
+
+    def [](name)
+      value = native.attribute_value(name.to_sym)
+      return value if value and not value.to_s.empty?
+    end
+
+    def value
+      if tag_name == "select" and native.multiple?
+        find(".//option[@selected]").map { |n| if n.has_value? then n.value else n.text end }
+      else
+        native.value
+      end
+    end
+
+    def set(value)
+      native.set(value)
+    end
+
+    def select_option
+      native.click
+    end
+
+    def unselect_option
+      unless select_node.native.multiple?
+        raise Capybara::UnselectNotAllowed, "Cannot unselect option from single select box."
+      end
+
+      # FIXME: couldn't find a clean way to unselect, so clear and reselect
+      selected_nodes = select_node.find('.//option[@selected]')
+      select_node.native.clear
+      selected_nodes.each { |n| n.click unless n.path == path }
+    end
+
+    def click
+      native.click
+    end
+
+    def drag_to(element)
+      native.fire_event('mousedown')
+      element.native.fire_event('mousemove')
+      element.native.fire_event('mouseup')
+    end
+
+    def tag_name
+      # FIXME: this might be the dumbest way ever of getting the tag name
+      # there has to be something better...
+      native.to_xml[/^\s*<([a-z0-9\-\:]+)/, 1]
+    end
+
+    def visible?
+      native.visible?
+    end
+
+    def checked?
+      native.checked?
+    rescue # https://github.com/langalex/culerity/issues/issue/33
+      false
+    end
+
+    def selected?
+      native.selected?
+    rescue # https://github.com/langalex/culerity/issues/issue/33
+      false
+    end
+
+    def path
+      native.xpath
+    end
+
+    def trigger(event)
+      native.fire_event(event.to_s)
+    end
+
+    def find(locator)
+      noko_node = Nokogiri::HTML(driver.body).xpath(native.xpath).first
+      all_nodes = noko_node.xpath(locator).map { |n| n.path }.join(' | ')
+      if all_nodes.empty? then [] else driver.find(all_nodes) end
+    end
+
+  protected
+
+    # a reference to the select node if this is an option node
+    def select_node
+      find('./ancestor::select').first
+    end
+
+    def has_value?
+      native.object.hasAttribute('value')
+    end
+  end
+
+  attr_reader :app, :rack_server, :options
+
+  def initialize(app, options={})
+    @app = app
+    @options = options
+    @rack_server = Capybara::Server.new(@app)
+    @rack_server.boot if Capybara.run_server
+  end
+
+  def visit(path)
+    browser.goto(url(path))
+  end
+
+  def current_url
+    browser.url
+  end
+
+  def source
+    browser.html
+  end
+
+  def body
+    browser.document.as_xml
+  end
+
+  def response_headers
+    browser.response_headers
+  end
+
+  def status_code
+    browser.status_code
+  end
+
+  def find(selector)
+    browser.elements_by_xpath(selector).map { |node| Node.new(self, node) }
+  end
+
+  def wait?; true; end
+
+  def execute_script(script)
+    browser.execute_script script
+    nil
+  end
+
+  def evaluate_script(script)
+    browser.execute_script "#{script}"
+  end
+
+  def browser
+    unless @_browser
+      require 'celerity'
+      @_browser = ::Celerity::Browser.new(options)
+    end
+
+    @_browser
+  end
+
+  def reset!
+    browser.clear_cookies
+  end
+
+private
+
+  def url(path)
+    rack_server.url(path)
+  end
+
+end