rcarvalho-capybara 0.4.1.1

data/lib/capybara/node/simple.rb

@@ -0,0 +1,116 @@
+module Capybara
+  module Node
+
+    ##
+    #
+    # A {Capybara::Node::Simple} is a simpler version of {Capybara::Node::Base} which
+    # includes only {Capybara::Node::Finders} and {Capybara::Node::Matchers} and does
+    # not include {Capybara::Node::Actions}. This type of node is returned when
+    # using {Capybara.string}.
+    #
+    # It is useful in that it does not require a session, an application or a driver,
+    # but can still use Capybara's finders and matchers on any string that contains HTML.
+    #
+    class Simple
+      include Capybara::Node::Finders
+      include Capybara::Node::Matchers
+
+      attr_reader :native
+
+      def initialize(native)
+        native = Nokogiri::HTML(native) if native.is_a?(String)
+        @native = native
+      end
+
+      ##
+      #
+      # @return [String]    The text of the element
+      #
+      def text
+        native.text
+      end
+
+      ##
+      #
+      # Retrieve the given attribute
+      #
+      #     element[:title] # => HTML title attribute
+      #
+      # @param  [Symbol] attribute     The attribute to retrieve
+      # @return [String]               The value of the attribute
+      #
+      def [](name)
+        attr_name = name.to_s
+        if attr_name == 'value'
+          value
+        elsif 'input' == tag_name and 'checkbox' == native[:type] and 'checked' == attr_name
+          native['checked'] == 'checked'
+        else
+          native[attr_name]
+        end
+      end
+
+      ##
+      #
+      # @return [String]      The tag name of the element
+      #
+      def tag_name
+        native.node_name
+      end
+
+      ##
+      #
+      # An XPath expression describing where on the page the element can be found
+      #
+      # @return [String]      An XPath expression
+      #
+      def path
+        native.path
+      end
+
+      ##
+      #
+      # @return [String]    The value of the form element
+      #
+      def value
+        if tag_name == 'textarea'
+          native.content
+        elsif tag_name == 'select'
+          if native['multiple'] == 'multiple'
+            native.xpath(".//option[@selected='selected']").map { |option| option[:value] || option.content  }
+          else
+            option = native.xpath(".//option[@selected='selected']").first || native.xpath(".//option").first
+            option[:value] || option.content if option
+          end
+        else
+          native[:value]
+        end
+      end
+
+      ##
+      #
+      # Whether or not the element is visible. Does not support CSS, so
+      # the result may be inaccurate.
+      #
+      # @return [Boolean]     Whether the element is visible
+      #
+      def visible?
+        native.xpath("./ancestor-or-self::*[contains(@style, 'display:none') or contains(@style, 'display: none')]").size == 0
+      end
+
+    protected
+
+      def find_in_base(xpath)
+        native.xpath(xpath).map { |node| self.class.new(node) }
+      end
+
+      def convert_element(element)
+        element
+      end
+
+      def wait?
+        false
+      end
+    end
+  end
+end

data/lib/capybara/rails.rb

@@ -0,0 +1,17 @@
+require 'capybara'
+require 'capybara/dsl'
+
+Capybara.app = Rack::Builder.new do
+  map "/" do
+    if Rails.version.to_f >= 3.0
+      run Rails.application  
+    else # Rails 2
+      use Rails::Rack::Static
+      run ActionController::Dispatcher.new
+    end
+  end
+end.to_app
+
+Capybara.asset_root = Rails.root.join('public')
+Capybara.save_and_open_page_path = Rails.root.join('tmp/capybara')
+

data/lib/capybara/rspec.rb

@@ -0,0 +1,18 @@
+require 'capybara'
+require 'capybara/dsl'
+
+RSpec.configure do |config|
+  config.include Capybara, :type => :acceptance
+  config.after do
+    if example.metadata[:type] == :acceptance
+      Capybara.reset_sessions!
+      Capybara.use_default_driver
+    end
+  end
+  config.before do
+    if example.metadata[:type] == :acceptance
+      Capybara.current_driver = Capybara.javascript_driver if example.metadata[:js]
+      Capybara.current_driver = example.metadata[:driver] if example.metadata[:driver]
+    end
+  end
+end

data/lib/capybara/selector.rb

@@ -0,0 +1,70 @@
+module Capybara
+  class Selector
+    attr_reader :name
+
+    class << self
+      def all
+        @selectors ||= {}
+      end
+
+      def add(name, &block)
+        all[name.to_sym] = Capybara::Selector.new(name.to_sym, &block)
+      end
+
+      def remove(name)
+        all.delete(name.to_sym)
+      end
+
+      def normalize(name_or_locator, locator=nil)
+        xpath = if locator
+          all[name_or_locator.to_sym].call(locator)
+        else
+          selector = all.values.find { |s| s.match?(name_or_locator) }
+          selector ||= all[Capybara.default_selector]
+          selector.call(name_or_locator)
+        end
+        if xpath.respond_to?(:to_xpaths)
+          xpath.to_xpaths
+        else
+          [xpath.to_s].flatten
+        end
+      end
+    end
+
+    def initialize(name, &block)
+      @name = name
+      instance_eval(&block)
+    end
+
+    def xpath(&block)
+      @xpath = block if block
+      @xpath
+    end
+
+    def match(&block)
+      @match = block if block
+      @match
+    end
+
+    def call(locator)
+      @xpath.call(locator)
+    end
+
+    def match?(locator)
+      @match and @match.call(locator)
+    end
+  end
+end
+
+Capybara.add_selector(:xpath) do
+  xpath { |xpath| xpath }
+end
+
+Capybara.add_selector(:css) do
+  xpath { |css| XPath.css(css) }
+end
+
+Capybara.add_selector(:id) do
+  xpath { |id| XPath.descendant[XPath.attr(:id) == id.to_s] }
+  match { |value| value.is_a?(Symbol) }
+end

data/lib/capybara/server.rb

@@ -0,0 +1,90 @@
+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
+      "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(Capybara.server_boot_timeout) do
+            if responsive? then true else sleep(0.5) and false end
+          end
+        end
+      end
+    rescue TimeoutError
+      puts "Rack application timed out during boot"
+      exit
+    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,281 @@
+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
+    DSL_METHODS = [
+      :all, :first, :attach_file, :body, :check, :choose, :click_link_or_button, :click_button, :click_link, :current_url, :drag, :drag_to_location, :evaluate_script,
+      :field_labeled, :fill_in, :find, :find_button, :find_by_id, :find_field, :find_link, :has_content?, :has_css?,
+      :has_no_content?, :has_no_css?, :has_no_xpath?, :has_xpath?, :locate, :save_and_open_page, :select, :source, :uncheck,
+      :visit, :wait_until, :within, :within_fieldset, :within_table, :within_frame, :within_window, :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?, :current_path, :click, :has_selector?, :has_no_selector?, :click_on
+    ]
+
+    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!
+
+    ##
+    #
+    # 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
+    #
+    def body
+      driver.body
+    end
+
+    ##
+    #
+    # @return [String] HTML source of the document, before being modified by JavaScript.
+    #
+    def source
+      driver.source
+    end
+
+    ##
+    #
+    # @return [String] Path of the current page, without any domain information
+    #
+    def current_path
+      URI.parse(current_url).path
+    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
+    #
+    # @param (see Capybara::Node::Finders#all)
+    # @raise  [Capybara::ElementNotFound]   If the scope can't be found before time expires
+    #
+    def within(*args)
+      new_scope = find(*args)
+      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 :xpath, XPath::HTML.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 :xpath, XPath::HTML.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 always 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_and_open_page
+      require 'capybara/util/save_and_open_page'
+      Capybara.save_and_open_page(body)
+    end
+
+    def document
+      Capybara::Node::Document.new(self, driver)
+    end
+
+    def method_missing(*args)
+      current_node.send(*args)
+    end
+
+    def respond_to?(method)
+      super || current_node.respond_to?(method)
+    end
+
+  private
+
+    def current_node
+      scopes.last
+    end
+
+    def scopes
+      @scopes ||= [document]
+    end
+  end
+end