capybara 0.4.1.2 → 1.0.0.beta1

data/lib/capybara/rack_test/driver.rb

@@ -0,0 +1,77 @@
+require 'rack/test'
+require 'rack/utils'
+require 'mime/types'
+require 'nokogiri'
+require 'cgi'
+
+class Capybara::RackTest::Driver < Capybara::Driver::Base
+  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 = options
+  end
+
+  def browser
+    @browser ||= Capybara::RackTest::Browser.new(app, options)
+  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

data/lib/capybara/rack_test/node.rb

@@ -0,0 +1,101 @@
+class Capybara::RackTest::Node < Capybara::Driver::Node
+  def text
+    native.text
+  end
+
+  def [](name)
+    string_node[name]
+  end
+
+  def value
+    string_node.value
+  end
+
+  def set(value)
+    if tag_name == 'input' and type == 'radio'
+      other_radios_xpath = XPath.generate { |x| x.anywhere(:input)[x.attr(:name).equals(self[:name])] }.to_s
+      driver.dom.xpath(other_radios_xpath).each { |node| node.remove_attribute("checked") }
+      native['checked'] = 'checked'
+    elsif tag_name == 'input' and type == 'checkbox'
+      if value && !native['checked']
+        native['checked'] = 'checked'
+      elsif !value && native['checked']
+        native.remove_attribute('checked')
+      end
+    elsif tag_name == 'input'
+      if (type == 'text' || type == 'password') && self[:maxlength]
+        value = value[0...self[:maxlength].to_i]
+      end
+      native['value'] = value.to_s
+    elsif tag_name == "textarea"
+      native.content = value.to_s
+    end
+  end
+
+  def select_option
+    if select_node['multiple'] != 'multiple'
+      select_node.find(".//option[@selected]").each { |node| node.native.remove_attribute("selected") }
+    end
+    native["selected"] = 'selected'
+  end
+
+  def unselect_option
+    if select_node['multiple'] != 'multiple'
+      raise Capybara::UnselectNotAllowed, "Cannot unselect option from single select box."
+    end
+    native.remove_attribute('selected')
+  end
+
+  def click
+    if tag_name == 'a'
+      method = self["data-method"] || :get
+      driver.follow(method, self[:href].to_s)
+    elsif (tag_name == 'input' and %w(submit image).include?(type)) or
+        ((tag_name == 'button') and type.nil? or type == "submit")
+      Capybara::RackTest::Form.new(driver, form).submit(self)
+    end
+  end
+
+  def tag_name
+    native.node_name
+  end
+
+  def visible?
+    string_node.visible?
+  end
+
+  def checked?
+    string_node.checked?
+  end
+
+  def selected?
+    string_node.selected?
+  end
+
+  def path
+    native.path
+  end
+
+  def find(locator)
+    native.xpath(locator).map { |n| self.class.new(driver, n) }
+  end
+
+private
+
+  def string_node
+    @string_node ||= Capybara::Node::Simple.new(native)
+  end
+
+  # a reference to the select node if this is an option node
+  def select_node
+    find('./ancestor::select').first
+  end
+
+  def type
+    native[:type]
+  end
+
+  def form
+    native.ancestors('form').first
+  end
+end

data/lib/capybara/rspec.rb

@@ -1,16 +1,24 @@
 require 'capybara'
 require 'capybara/dsl'
+require 'rspec/core'
+require 'capybara/rspec/matchers'
+require 'capybara/rspec/features'
 
 RSpec.configure do |config|
-  config.include Capybara, :type => :acceptance
+  config.include Capybara::DSL, :type => :request
+  config.include Capybara::DSL, :type => :acceptance
+  config.include Capybara::RSpecMatchers, :type => :request
+  config.include Capybara::RSpecMatchers, :type => :acceptance
+  # The before and after blocks must run instantaneously, because Capybara
+  # might not actually be used in all examples where it's included.
   config.after do
-    if example.metadata[:type] == :acceptance
+    if self.class.include?(Capybara::DSL)
       Capybara.reset_sessions!
       Capybara.use_default_driver
     end
   end
   config.before do
-    if example.metadata[:type] == :acceptance
+    if self.class.include?(Capybara::DSL)
       Capybara.current_driver = Capybara.javascript_driver if example.metadata[:js]
       Capybara.current_driver = example.metadata[:driver] if example.metadata[:driver]
     end

data/lib/capybara/rspec/features.rb

@@ -0,0 +1,22 @@
+module Capybara
+  module Features
+    def self.included(base)
+      base.instance_eval do
+        alias :background :before
+        alias :scenario :it
+      end
+    end
+  end
+end
+
+def self.feature(*args, &block)
+  options = if args.last.is_a?(Hash) then args.pop else {} end
+  options[:capybara_feature] = true
+  options[:type] = :request
+  options[:caller] ||= caller
+  args.push(options)
+
+  describe(*args, &block)
+end
+
+RSpec.configuration.include Capybara::Features, :capybara_feature => true

data/lib/capybara/rspec/matchers.rb

@@ -0,0 +1,146 @@
+module Capybara
+  module RSpecMatchers
+    class HaveSelector
+      def initialize(*args)
+        @args = args
+      end
+
+      def matches?(actual)
+        @actual = wrap(actual)
+        @actual.has_selector?(*@args)
+      end
+
+      def does_not_match?(actual)
+        @actual = wrap(actual)
+        @actual.has_no_selector?(*@args)
+      end
+
+      def failure_message_for_should
+        if normalized.failure_message
+          normalized.failure_message.call(@actual, normalized)
+        else
+          "expected #{selector_name} to return something"
+        end
+      end
+
+      def failure_message_for_should_not
+        "expected #{selector_name} not to return anything"
+      end
+
+      def selector_name
+        name = "#{normalized.name} #{normalized.locator.inspect}"
+        name << " with text #{normalized.options[:text].inspect}" if normalized.options[:text]
+        name
+      end
+
+      def wrap(actual)
+        if actual.respond_to?("has_selector?")
+          actual
+        else
+          Capybara.string(actual.to_s)
+        end
+      end
+
+      def normalized
+        @normalized ||= Capybara::Selector.normalize(*@args)
+      end
+    end
+
+    class HaveMatcher
+      attr_reader :name, :locator, :options, :failure_message, :actual
+
+      def initialize(name, locator, options={}, &block)
+        @name = name
+        @locator = locator
+        @options = options
+        @failure_message = block
+      end
+
+      def arguments
+        if options.empty? then [locator] else [locator, options] end
+      end
+
+      def matches?(actual)
+        @actual = wrap(actual)
+        @actual.send(:"has_#{name}?", *arguments)
+      end
+
+      def does_not_match?(actual)
+        @actual = wrap(actual)
+        @actual.send(:"has_no_#{name}?", *arguments)
+      end
+
+      def failure_message_for_should
+        if failure_message
+          failure_message.call(actual, self)
+        else
+          "expected #{selector_name} to return something"
+        end
+      end
+
+      def failure_message_for_should_not
+        "expected #{selector_name} not to return anything"
+      end
+
+      def selector_name
+        selector_name = "#{name} #{locator.inspect}"
+        selector_name << " with text #{options[:text].inspect}" if options[:text]
+        selector_name
+      end
+
+      def wrap(actual)
+        if actual.respond_to?("has_selector?")
+          actual
+        else
+          Capybara.string(actual.to_s)
+        end
+      end
+    end
+
+    def have_selector(*args)
+      HaveSelector.new(*args)
+    end
+
+    def have_xpath(xpath, options={})
+      HaveMatcher.new(:xpath, xpath, options)
+    end
+
+    def have_css(css, options={})
+      HaveMatcher.new(:css, css, options)
+    end
+
+    def have_content(text)
+      HaveMatcher.new(:content, text.to_s) do |page, matcher|
+        %(expected there to be content #{matcher.locator.inspect} in #{page.text.inspect})
+      end
+    end
+
+    def have_link(locator, options={})
+      HaveMatcher.new(:link, locator, options)
+    end
+
+    def have_button(locator)
+      HaveMatcher.new(:button, locator)
+    end
+
+    def have_field(locator, options={})
+      HaveMatcher.new(:field, locator, options)
+    end
+
+    def have_checked_field(locator)
+      HaveMatcher.new(:checked_field, locator)
+    end
+
+    def have_unchecked_field(locator)
+      HaveMatcher.new(:unchecked_field, locator)
+    end
+
+    def have_select(locator, options={})
+      HaveMatcher.new(:select, locator, options)
+    end
+
+    def have_table(locator, options={})
+      HaveMatcher.new(:table, locator, options)
+    end
+  end
+end