bbc-capybara 1.1.2

data/lib/capybara/node/simple.rb

@@ -0,0 +1,132 @@
+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') or name()='script' or name()='head']").size == 0
+      end
+
+      ##
+      #
+      # Whether or not the element is checked.
+      #
+      # @return [Boolean]     Whether the element is checked
+      #
+      def checked?
+        native[:checked]
+      end
+
+      ##
+      #
+      # Whether or not the element is selected.
+      #
+      # @return [Boolean]     Whether the element is selected
+      #
+      def selected?
+        native[:selected]
+      end
+
+    protected
+
+      def find_in_base(selector, xpath)
+        native.xpath(xpath).map { |node| self.class.new(node) }
+      end
+
+      def wait_until
+        yield # simple nodes don't need to wait
+      end
+    end
+  end
+end

data/lib/capybara/query.rb

@@ -0,0 +1,63 @@
+module Capybara
+  class Query
+    attr_accessor :selector, :locator, :options, :xpaths
+
+    def initialize(*args)
+      @options = if args.last.is_a?(Hash) then args.pop.dup else {} end
+      unless options.has_key?(:visible)
+        @options[:visible] = Capybara.ignore_hidden_elements
+      end
+
+      if args[1]
+        @selector = Selector.all[args[0]]
+        @locator = args[1]
+      else
+        @selector = Selector.all.values.find { |s| s.match?(args[0]) }
+        @locator = args[0]
+      end
+      @selector ||= Selector.all[Capybara.default_selector]
+
+      xpath = @selector.call(@locator)
+      if xpath.respond_to?(:to_xpaths)
+        @xpaths = xpath.to_xpaths
+      else
+        @xpaths = [xpath.to_s].flatten
+      end
+    end
+
+    def failure_message(type, node)
+      message = selector.failure_message.call(node, self) if selector.failure_message
+      message ||= options[:message]
+      if type == :assert
+        message ||= "expected #{description} to return something"
+      else
+        message ||= "Unable to find #{description}"
+      end
+      message
+    end
+
+    def negative_failure_message(type, node)
+      "expected #{description} not to return anything"
+    end
+
+    def name; selector.name; end
+
+    def description
+      @description = "#{name} #{locator.inspect}"
+      @description << " with text #{options[:text].inspect}" if options[:text]
+      @description
+    end
+
+    def matches_filters?(node)
+      if options[:text]
+        regexp = options[:text].is_a?(Regexp) ? options[:text] : Regexp.escape(options[:text])
+        return false if not node.text.match(regexp)
+      end
+      return false if options[:visible] and not node.visible?
+      selector.custom_filters.each do |name, block|
+        return false if options.has_key?(name) and not block.call(node, options[name])
+      end
+      true
+    end
+  end
+end

data/lib/capybara/rack_test/browser.rb

@@ -0,0 +1,126 @@
+class Capybara::RackTest::Browser
+  include ::Rack::Test::Methods
+
+  attr_reader :driver
+  attr_accessor :current_host
+
+  def initialize(driver)
+    @driver = driver
+  end
+
+  def app
+    driver.app
+  end
+
+  def options
+    driver.options
+  end
+
+  def visit(path, attributes = {})
+    reset_host!
+    process(:get, path, attributes)
+    follow_redirects!
+  end
+
+  def submit(method, path, attributes)
+    path = request_path if not path or path.empty?
+    process(method, path, attributes)
+    follow_redirects!
+  end
+
+  def follow(method, path, attributes = {})
+    return if path.gsub(/^#{request_path}/, '').start_with?('#')
+    process(method, path, attributes)
+    follow_redirects!
+  end
+
+  def follow_redirects!
+    5.times do
+      process(:get, last_response["Location"]) if last_response.redirect?
+    end
+    raise Capybara::InfiniteRedirectError, "redirected more than 5 times, check for infinite redirects." if last_response.redirect?
+  end
+
+  def process(method, path, attributes = {})
+    new_uri = URI.parse(path)
+    method.downcase! unless method.is_a? Symbol
+
+    if new_uri.host
+      @current_host = "#{new_uri.scheme}://#{new_uri.host}"
+      @current_host << ":#{new_uri.port}" if new_uri.port != new_uri.default_port
+    end
+
+    if new_uri.relative?
+      if path.start_with?('?')
+        path = request_path + path
+      elsif not path.start_with?('/')
+        path = request_path.sub(%r(/[^/]*$), '/') + path
+      end
+      path = current_host + path
+    end
+
+    reset_cache!
+    send(method, path, attributes, env)
+  end
+
+  def current_url
+    last_request.url
+  rescue Rack::Test::Error
+    ""
+  end
+
+  def reset_host!
+    @current_host = (Capybara.app_host || Capybara.default_host)
+  end
+
+  def reset_cache!
+    @dom = nil
+  end
+
+  def body
+    dom.to_xml
+  end
+
+  def dom
+    @dom ||= Nokogiri::HTML(source)
+  end
+
+  def find(selector)
+    dom.xpath(selector).map { |node| Capybara::RackTest::Node.new(self, node) }
+  end
+
+  def source
+    last_response.body
+  rescue Rack::Test::Error
+    ""
+  end
+
+protected
+
+  def build_rack_mock_session
+    reset_host! unless current_host
+    Rack::MockSession.new(app, URI.parse(current_host).host)
+  end
+
+  def request_path
+    last_request.path
+  rescue Rack::Test::Error
+    ""
+  end
+
+  def env
+    env = {}
+    begin
+      if last_response.redirect?
+        env["HTTP_REFERER"] = last_request.env["HTTP_REFERER"]
+      else
+        env["HTTP_REFERER"] = last_request.url
+      end
+    rescue Rack::Test::Error
+      # no request yet
+    end
+    env.merge!(options[:headers]) if options[:headers]
+    env
+  end
+
+end

data/lib/capybara/rack_test/driver.rb

@@ -0,0 +1,80 @@
+require 'rack/test'
+require 'rack/utils'
+require 'mime/types'
+require 'nokogiri'
+require 'cgi'
+
+class Capybara::RackTest::Driver < Capybara::Driver::Base
+  DEFAULT_OPTIONS = {
+    :respect_data_method => true
+  }
+  attr_reader :app, :options
+
+  def initialize(app, options={})
+    raise ArgumentError, "rack-test requires a rack application, but none was given" unless app
+    @app = app
+    @options = DEFAULT_OPTIONS.merge(options)
+  end
+
+  def browser
+    @browser ||= Capybara::RackTest::Browser.new(self)
+  end
+
+  def response
+    browser.last_response
+  end
+
+  def request
+    browser.last_request
+  end
+
+  def visit(path, attributes = {})
+    browser.visit(path, attributes)
+  end
+
+  def submit(method, path, attributes)
+    browser.submit(method, path, attributes)
+  end
+
+  def follow(method, path, attributes = {})
+    browser.follow(method, path, attributes)
+  end
+
+  def current_url
+    browser.current_url
+  end
+
+  def response_headers
+    response.headers
+  end
+
+  def status_code
+    response.status
+  end
+
+  def find(selector)
+    browser.find(selector)
+  end
+
+  def body
+    browser.body
+  end
+
+  def source
+    browser.source
+  end
+
+  def dom
+    browser.dom
+  end
+
+  def reset!
+    @browser = nil
+  end
+
+  def get(*args, &block); browser.get(*args, &block); end
+  def post(*args, &block); browser.post(*args, &block); end
+  def put(*args, &block); browser.put(*args, &block); end
+  def delete(*args, &block); browser.delete(*args, &block); end
+  def header(key, value); browser.header(key, value); end
+end

data/lib/capybara/rack_test/form.rb

@@ -0,0 +1,80 @@
+class Capybara::RackTest::Form < Capybara::RackTest::Node
+  # This only needs to inherit from Rack::Test::UploadedFile because Rack::Test checks for
+  # the class specifically when determing whether to consturct the request as multipart.
+  # That check should be based solely on the form element's 'enctype' attribute value,
+  # which should probably be provided to Rack::Test in its non-GET request methods.
+  class NilUploadedFile < Rack::Test::UploadedFile
+    def initialize
+      @empty_file = Tempfile.new("nil_uploaded_file")
+      @empty_file.close
+    end
+
+    def original_filename; ""; end
+    def content_type; "application/octet-stream"; end
+    def path; @empty_file.path; end
+  end
+
+  def params(button)
+    params = {}
+
+    native.xpath("(.//input|.//select|.//textarea)[not(@disabled)]").map do |field|
+      case field.name
+      when 'input'
+        if %w(radio checkbox).include? field['type']
+          merge_param!(params, field['name'].to_s, field['value'].to_s) if field['checked']
+        elsif %w(submit image).include? field['type']
+          # TO DO identify the click button here (in document order, rather
+          # than leaving until the end of the params)
+        elsif field['type'] =='file'
+          if multipart?
+            file = \
+              if (value = field['value']).to_s.empty?
+                NilUploadedFile.new
+              else
+                content_type = MIME::Types.type_for(value).first.to_s
+                Rack::Test::UploadedFile.new(value, content_type)
+              end
+            merge_param!(params, field['name'].to_s, file)
+          else
+            merge_param!(params, field['name'].to_s, File.basename(field['value'].to_s))
+          end
+        else
+          merge_param!(params, field['name'].to_s, field['value'].to_s)
+        end
+      when 'select'
+        if field['multiple'] == 'multiple'
+          options = field.xpath(".//option[@selected]")
+          options.each do |option|
+            merge_param!(params, field['name'].to_s, (option['value'] || option.text).to_s)
+          end
+        else
+          option = field.xpath(".//option[@selected]").first
+          option ||= field.xpath('.//option').first
+          merge_param!(params, field['name'].to_s, (option['value'] || option.text).to_s) if option
+        end
+      when 'textarea'
+        merge_param!(params, field['name'].to_s, field.text.to_s)
+      end
+    end
+    merge_param!(params, button[:name], button[:value] || "") if button[:name]
+    params
+  end
+
+  def submit(button)
+    driver.submit(method, native['action'].to_s, params(button))
+  end
+
+  def multipart?
+    self[:enctype] == "multipart/form-data"
+  end
+
+private
+
+  def method
+    self[:method] =~ /post/i ? :post : :get
+  end
+
+  def merge_param!(params, key, value)
+    Rack::Utils.normalize_params(params, key, value)
+  end
+end